@remotion/media-parser 4.0.304 → 4.0.306

package/dist/esm/worker-web-entry.mjs

@@ -2328,7 +2328,7 @@ var bufferManager = ({
   counter
 }) => {
   const buf = new ArrayBuffer(initialData.byteLength, {
-    maxByteLength: maxBytes === null ? initialData.byteLength : Math.min(maxBytes, 2 ** 32)
+    maxByteLength: maxBytes === null ? initialData.byteLength : Math.min(maxBytes, 2 ** 31)
   });
   if (!buf.resize) {
     throw new Error("`ArrayBuffer.resize` is not supported in this Runtime. On the server: Use at least Node.js 20 or Bun. In the browser: Chrome 111, Edge 111, Safari 16.4, Firefox 128, Opera 111");
@@ -2999,6 +2999,9 @@ var getVideoCodecString = (trakBox) => {
   return videoSample.format;
 };
 
+// src/webcodecs-timescale.ts
+var WEBCODECS_TIMESCALE = 1e6;
+
 // src/containers/iso-base-media/color-to-webcodecs-colors.ts
 var mediaParserAdvancedColorToWebCodecsColor = (color2) => {
   return {
@@ -3268,23 +3271,25 @@ var makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
     return {
       type: "audio",
       trackId: tkhdBox.trackId,
-      timescale: timescaleAndDuration.timescale,
+      originalTimescale: timescaleAndDuration.timescale,
       codec: codecString,
       numberOfChannels: actual.numberOfChannels,
       sampleRate: actual.sampleRate,
       description: actual.codecPrivate?.data ?? undefined,
       codecData: actual.codecPrivate,
       codecEnum,
-      startInSeconds: startTimeInSeconds
+      startInSeconds: startTimeInSeconds,
+      timescale: WEBCODECS_TIMESCALE
     };
   }
   if (!trakBoxContainsVideo(trakBox)) {
     return {
       type: "other",
       trackId: tkhdBox.trackId,
-      timescale: timescaleAndDuration.timescale,
+      originalTimescale: timescaleAndDuration.timescale,
       trakBox,
-      startInSeconds: startTimeInSeconds
+      startInSeconds: startTimeInSeconds,
+      timescale: WEBCODECS_TIMESCALE
     };
   }
   const videoSample = getStsdVideoConfig(trakBox);
@@ -3317,7 +3322,7 @@ var makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
     type: "video",
     trackId: tkhdBox.trackId,
     description: videoDescriptors ?? undefined,
-    timescale: timescaleAndDuration.timescale,
+    originalTimescale: timescaleAndDuration.timescale,
     codec,
     sampleAspectRatio: getSampleAspectRatio(trakBox),
     width,
@@ -3332,7 +3337,8 @@ var makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
     advancedColor,
     codecEnum: getVideoCodecFromIsoTrak(trakBox),
     fps: getFpsFromMp4TrakBox(trakBox),
-    startInSeconds: startTimeInSeconds
+    startInSeconds: startTimeInSeconds,
+    timescale: WEBCODECS_TIMESCALE
   };
   return track;
 };
@@ -3455,9 +3461,10 @@ var makeAviAudioTrack = ({
     description: new Uint8Array([18, 16]),
     numberOfChannels: strf.numberOfChannels,
     sampleRate: strf.sampleRate,
-    timescale: MEDIA_PARSER_RIFF_TIMESCALE,
+    originalTimescale: MEDIA_PARSER_RIFF_TIMESCALE,
     trackId: index,
-    startInSeconds: 0
+    startInSeconds: 0,
+    timescale: WEBCODECS_TIMESCALE
   };
 };
 var makeAviVideoTrack = ({
@@ -3478,7 +3485,7 @@ var makeAviVideoTrack = ({
     height: strf.height,
     type: "video",
     displayAspectHeight: strf.height,
-    timescale: MEDIA_PARSER_RIFF_TIMESCALE,
+    originalTimescale: MEDIA_PARSER_RIFF_TIMESCALE,
     description: undefined,
     m3uStreamFormat: null,
     trackId: index,
@@ -3501,7 +3508,8 @@ var makeAviVideoTrack = ({
       denominator: 1
     },
     fps: strh.rate / strh.scale,
-    startInSeconds: 0
+    startInSeconds: 0,
+    timescale: WEBCODECS_TIMESCALE
   };
 };
 var getTracksFromAvi = (structure, state) => {
@@ -4144,7 +4152,7 @@ var getTrack = ({
         numerator: 1,
         denominator: 1
       },
-      timescale,
+      originalTimescale: timescale,
       codedHeight: height.value.value,
       codedWidth: width.value.value,
       displayAspectHeight: displayHeight2 ? displayHeight2.value.value : height.value.value,
@@ -4155,7 +4163,8 @@ var getTrack = ({
       advancedColor,
       codecEnum,
       fps: null,
-      startInSeconds: 0
+      startInSeconds: 0,
+      timescale: WEBCODECS_TIMESCALE
     };
   }
   if (trackTypeToString(trackType2.value.value) === "audio") {
@@ -4170,7 +4179,7 @@ var getTrack = ({
       type: "audio",
       trackId,
       codec: codecString,
-      timescale,
+      originalTimescale: timescale,
       numberOfChannels,
       sampleRate,
       description: getAudioDescription(track),
@@ -4178,7 +4187,8 @@ var getTrack = ({
       codecEnum: getMatroskaAudioCodecEnum({
         track
       }),
-      startInSeconds: 0
+      startInSeconds: 0,
+      timescale: WEBCODECS_TIMESCALE
     };
   }
   return null;
@@ -4738,8 +4748,8 @@ var getSamplesFromTraf = (trafSegment, moofOffset) => {
       const dts = time + (tfdtBox?.baseMediaDecodeTime ?? 0);
       const samplePosition = {
         offset: offset + (moofOffset ?? 0) + (dataOffset ?? 0),
-        dts,
-        cts: dts + (sample.sampleCompositionTimeOffset ?? 0),
+        decodingTimestamp: dts,
+        timestamp: dts + (sample.sampleCompositionTimeOffset ?? 0),
         duration: duration2,
         isKeyframe: keyframe,
         size,
@@ -4830,8 +4840,8 @@ var getSamplePositions = ({
         offset: Number(chunks[i]) + offsetInThisChunk,
         size,
         isKeyframe,
-        dts,
-        cts,
+        decodingTimestamp: dts,
+        timestamp: cts,
         duration: delta,
         chunk: i,
         bigEndian: false,
@@ -4880,8 +4890,8 @@ var getGroupedSamplesPositionsFromMp4 = ({
     }
     samples.push({
       chunk,
-      cts: timestamp,
-      dts: timestamp,
+      timestamp,
+      decodingTimestamp: timestamp,
       offset: Number(entry),
       size: stszBox.sampleSize * samplesPerChunk,
       duration: samplesPerChunk,
@@ -5241,7 +5251,7 @@ var getDurationFromIsoBaseMedia = (parserState) => {
   }
   const tracks2 = getTracks(parserState, true);
   const allSamples = tracks2.map((t) => {
-    const { timescale: ts } = t;
+    const { originalTimescale: ts } = t;
     const trakBox = getTrakBoxByTrackId(moovBox, t.trackId);
     if (!trakBox) {
       return null;
@@ -5257,7 +5267,7 @@ var getDurationFromIsoBaseMedia = (parserState) => {
     if (samplePositions.length === 0) {
       return null;
     }
-    const highest = samplePositions?.map((sp) => (sp.cts + sp.duration) / ts).reduce((a, b) => Math.max(a, b), 0);
+    const highest = samplePositions?.map((sp) => (sp.timestamp + sp.duration) / ts).reduce((a, b) => Math.max(a, b), 0);
     return highest ?? 0;
   });
   if (allSamples.every((s) => s === null)) {
@@ -5344,7 +5354,7 @@ var getKeyframesFromIsoBaseMedia = (state) => {
     return [];
   }
   const allSamples = videoTracks.map((t) => {
-    const { timescale: ts } = t;
+    const { originalTimescale: ts } = t;
     const trakBox = getTrakBoxByTrackId(moov, t.trackId);
     if (!trakBox) {
       return [];
@@ -5365,8 +5375,8 @@ var getKeyframesFromIsoBaseMedia = (state) => {
     }).map((k) => {
       return {
         trackId: t.trackId,
-        presentationTimeInSeconds: k.cts / ts,
-        decodingTimeInSeconds: k.dts / ts,
+        presentationTimeInSeconds: k.timestamp / ts,
+        decodingTimeInSeconds: k.decodingTimestamp / ts,
         positionInBytes: k.offset,
         sizeInBytes: k.size
       };
@@ -5775,8 +5785,8 @@ var findKeyframeBeforeTime = ({
   let videoByte = 0;
   let videoSample = null;
   for (const sample of samplePositions) {
-    const ctsInSeconds = sample.cts / timescale + startInSeconds;
-    const dtsInSeconds = sample.dts / timescale + startInSeconds;
+    const ctsInSeconds = sample.timestamp / timescale + startInSeconds;
+    const dtsInSeconds = sample.decodingTimestamp / timescale + startInSeconds;
     if (!sample.isKeyframe) {
       continue;
     }
@@ -5928,8 +5938,8 @@ var getSamplePositionBounds = (samplePositions, timescale) => {
   let min = Infinity;
   let max = -Infinity;
   for (const samplePosition of samplePositions) {
-    const timestampMin = Math.min(samplePosition.cts, samplePosition.dts);
-    const timestampMax = Math.max(samplePosition.cts, samplePosition.dts) + (samplePosition.duration ?? 0);
+    const timestampMin = Math.min(samplePosition.timestamp, samplePosition.decodingTimestamp);
+    const timestampMax = Math.max(samplePosition.timestamp, samplePosition.decodingTimestamp) + (samplePosition.duration ?? 0);
     if (timestampMin < min) {
       min = timestampMin;
     }
@@ -6013,13 +6023,13 @@ var getSeekingByteFromFragmentedMp4 = async ({
   });
   Log.trace(logLevel, "Fragmented MP4 - Checking if we have seeking info for this time range");
   for (const positions of samplePositionsArray) {
-    const { min, max } = getSamplePositionBounds(positions.samples, firstTrack.timescale);
+    const { min, max } = getSamplePositionBounds(positions.samples, firstTrack.originalTimescale);
     if (min <= time && (positions.isLastFragment || isLastChunkInPlaylist || time <= max)) {
       Log.trace(logLevel, `Fragmented MP4 - Found that we have seeking info for this time range: ${min} <= ${time} <= ${max}`);
       const kf = findKeyframeBeforeTime({
         samplePositions: positions.samples,
         time,
-        timescale: firstTrack.timescale,
+        timescale: firstTrack.originalTimescale,
         logLevel,
         mediaSections: info.mediaSections,
         startInSeconds: firstTrack.startInSeconds
@@ -6038,7 +6048,7 @@ var getSeekingByteFromFragmentedMp4 = async ({
       mfra: atom,
       time,
       firstTrack,
-      timescale: firstTrack.timescale
+      timescale: firstTrack.originalTimescale
     });
     if (moofOffset !== null && !(moofOffset.start <= currentPosition && currentPosition < moofOffset.end)) {
       Log.verbose(logLevel, `Fragmented MP4 - Found based on mfra information that we should seek to: ${moofOffset.start} ${moofOffset.end}`);
@@ -6122,7 +6132,7 @@ var getSeekingByteFromIsoBaseMedia = ({
   const keyframe = findKeyframeBeforeTime({
     samplePositions,
     time,
-    timescale: track.timescale,
+    timescale: track.originalTimescale,
     logLevel,
     mediaSections: info.mediaSections,
     startInSeconds: track.startInSeconds
@@ -6600,7 +6610,6 @@ var getSeekingByteFromMatroska = async ({
 };
 
 // src/convert-audio-or-video-sample.ts
-var TARGET_TIMESCALE = 1e6;
 var fixFloat = (value) => {
   if (value % 1 < 0.0000001) {
     return Math.floor(value);
@@ -6614,20 +6623,17 @@ var convertAudioOrVideoSampleToWebCodecsTimestamps = ({
   sample,
   timescale
 }) => {
-  if (timescale === TARGET_TIMESCALE) {
+  if (timescale === 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)),
-    duration: sample.duration === undefined ? undefined : fixFloat(sample.duration * (TARGET_TIMESCALE / timescale)),
+    decodingTimestamp: fixFloat(dts * (WEBCODECS_TIMESCALE / timescale)),
+    timestamp: fixFloat(timestamp * (WEBCODECS_TIMESCALE / timescale)),
+    duration: sample.duration === undefined ? undefined : fixFloat(sample.duration * (WEBCODECS_TIMESCALE / timescale)),
     data: sample.data,
-    trackId: sample.trackId,
     type: sample.type,
     offset: sample.offset,
-    timescale: TARGET_TIMESCALE,
     ..."avc" in sample ? { avc: sample.avc } : {}
   };
 };
@@ -7088,7 +7094,7 @@ var handleAvcPacket = async ({
       rotation: 0,
       trackId: programId,
       type: "video",
-      timescale: MPEG_TIMESCALE,
+      originalTimescale: MPEG_TIMESCALE,
       codec: getCodecStringFromSpsAndPps(spsAndPps.sps),
       codecData: { type: "avc-sps-pps", data: codecPrivate2 },
       fps: null,
@@ -7106,7 +7112,8 @@ var handleAvcPacket = async ({
       },
       colorSpace: mediaParserAdvancedColorToWebCodecsColor(advancedColor),
       advancedColor,
-      startInSeconds: 0
+      startInSeconds: 0,
+      timescale: WEBCODECS_TIMESCALE
     };
     await registerVideoTrack({
       track,
@@ -7119,15 +7126,12 @@ var handleAvcPacket = async ({
   }
   const type = getKeyFrameOrDeltaFromAvcInfo(avc);
   const sample = {
-    cts: streamBuffer.pesHeader.pts - transportStream.startOffset.getOffset(programId),
-    dts: (streamBuffer.pesHeader.dts ?? streamBuffer.pesHeader.pts) - transportStream.startOffset.getOffset(programId),
+    decodingTimestamp: (streamBuffer.pesHeader.dts ?? 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: MPEG_TIMESCALE
+    offset
   };
   if (type === "key") {
     transportStream.observedPesHeaders.markPtsAsKeyframe(streamBuffer.pesHeader.pts);
@@ -7136,7 +7140,10 @@ var handleAvcPacket = async ({
     sample,
     timescale: MPEG_TIMESCALE
   });
-  await sampleCallbacks.onVideoSample(programId, videoSample);
+  await sampleCallbacks.onVideoSample({
+    videoSample,
+    trackId: programId
+  });
   transportStream.lastEmittedSample.setLastEmittedSample(sample);
 };
 
@@ -7484,7 +7491,7 @@ var getSeekingHintsFromMatroska = (tracksState, keyframesState, webmState) => {
   return {
     type: "webm-seeking-hints",
     track: firstVideoTrack ? {
-      timescale: firstVideoTrack.timescale,
+      timescale: firstVideoTrack.originalTimescale,
       trackId: firstVideoTrack.trackId
     } : null,
     keyframes,
@@ -8613,10 +8620,11 @@ var parseAac = async (state) => {
         description: codecPrivate2,
         numberOfChannels: channelConfiguration,
         sampleRate,
-        timescale: 1e6,
+        originalTimescale: WEBCODECS_TIMESCALE,
         trackId: 0,
         type: "audio",
-        startInSeconds: 0
+        startInSeconds: 0,
+        timescale: WEBCODECS_TIMESCALE
       },
       registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
       tracks: state.callbacks.tracks,
@@ -8639,15 +8647,15 @@ var parseAac = async (state) => {
       type: "key",
       data,
       offset: startOffset,
-      timescale: 1e6,
-      trackId: 0,
-      cts: timestamp,
-      dts: timestamp,
+      decodingTimestamp: timestamp,
       timestamp
     },
     timescale: 1
   });
-  await state.callbacks.onAudioSample(0, audioSample);
+  await state.callbacks.onAudioSample({
+    audioSample,
+    trackId: 0
+  });
   return Promise.resolve(null);
 };
 
@@ -8825,7 +8833,7 @@ var emitSample = async ({
   data,
   offset
 }) => {
-  const iterator = getArrayBufferIterator(data, null);
+  const iterator = getArrayBufferIterator(data, data.length);
   const parsed = parseFrameHeader({ iterator, state });
   if (!parsed) {
     throw new Error("Invalid CRC");
@@ -8850,17 +8858,17 @@ var emitSample = async ({
     sample: {
       data,
       duration: duration2,
-      cts: timestamp,
-      dts: timestamp,
+      decodingTimestamp: timestamp,
       timestamp,
       type: "key",
-      offset,
-      timescale: 1,
-      trackId: 0
+      offset
     },
     timescale: 1
   });
-  await state.callbacks.onAudioSample(0, audioSample);
+  await state.callbacks.onAudioSample({
+    audioSample,
+    trackId: 0
+  });
   iterator.destroy();
 };
 var parseFlacFrame = async ({
@@ -9016,9 +9024,10 @@ var parseStreamInfo = async ({
       codecEnum: "flac",
       numberOfChannels: channels2,
       sampleRate,
-      timescale: 1e6,
+      originalTimescale: WEBCODECS_TIMESCALE,
       trackId: 0,
-      startInSeconds: 0
+      startInSeconds: 0,
+      timescale: WEBCODECS_TIMESCALE
     },
     registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
     tracks: state.callbacks.tracks,
@@ -9934,7 +9943,7 @@ var parseAvcc = ({
 
 // src/containers/iso-base-media/parse-icc-profile.ts
 var parseIccProfile = (data) => {
-  const iterator = getArrayBufferIterator(data, Infinity);
+  const iterator = getArrayBufferIterator(data, data.length);
   const size = iterator.getUint32();
   if (size !== data.length) {
     throw new Error("Invalid ICC profile size");
@@ -9979,7 +9988,7 @@ var parseIccProfile = (data) => {
   for (const entry of entries) {
     const found = data.slice(entry.offset, entry.offset + entry.size);
     if (entry.tag === "rXYZ" || entry.tag === "gXYZ" || entry.tag === "bXYZ" || entry.tag === "wtpt") {
-      const it = getArrayBufferIterator(found, Infinity);
+      const it = getArrayBufferIterator(found, found.length);
       it.discard(4);
       const x = it.getInt32() / 65536;
       const y = it.getInt32() / 65536;
@@ -11405,7 +11414,7 @@ var getMoovAtom = async ({
 // src/containers/iso-base-media/mdat/calculate-jump-marks.ts
 var MAX_SPREAD_IN_SECONDS = 8;
 var getKey = (samplePositionTrack) => {
-  return `${samplePositionTrack.track.trackId}-${samplePositionTrack.samplePosition.dts}`;
+  return `${samplePositionTrack.track.trackId}-${samplePositionTrack.samplePosition.decodingTimestamp}`;
 };
 var findBestJump = ({
   allSamplesSortedByOffset,
@@ -11498,7 +11507,7 @@ var calculateJumpMarks = (samplePositionTracks, endOfMdat) => {
       addFinalJumpIfNecessary();
       break;
     }
-    const timestamp = currentSamplePosition.samplePosition.dts / currentSamplePosition.track.timescale;
+    const timestamp = currentSamplePosition.samplePosition.decodingTimestamp / currentSamplePosition.track.originalTimescale;
     progresses[currentSamplePosition.track.trackId] = timestamp;
     const progressValues = Object.values(progresses);
     const maxProgress = Math.max(...progressValues);
@@ -11617,17 +11626,17 @@ var parseMdatSection = async (state) => {
     return makeFetchMoreData(samplesWithIndex.samplePosition.size - iterator.bytesRemaining());
   }
   const {
-    cts: rawCts,
-    dts: rawDts,
+    timestamp: rawCts,
+    decodingTimestamp: rawDts,
     duration: duration2,
     isKeyframe,
     offset,
     bigEndian,
     chunkSize
   } = samplesWithIndex.samplePosition;
-  const { timescale, startInSeconds } = samplesWithIndex.track;
-  const cts = rawCts + startInSeconds * timescale;
-  const dts = rawDts + startInSeconds * timescale;
+  const { originalTimescale, startInSeconds } = samplesWithIndex.track;
+  const cts = rawCts + startInSeconds * originalTimescale;
+  const dts = rawDts + startInSeconds * originalTimescale;
   const bytes = postprocessBytes({
     bytes: iterator.getSlice(samplesWithIndex.samplePosition.size),
     bigEndian,
@@ -11639,16 +11648,16 @@ var parseMdatSection = async (state) => {
         data: bytes,
         timestamp: cts,
         duration: duration2,
-        cts,
-        dts,
-        trackId: samplesWithIndex.track.trackId,
+        decodingTimestamp: dts,
         type: isKeyframe ? "key" : "delta",
-        offset,
-        timescale
+        offset
       },
-      timescale
+      timescale: originalTimescale
+    });
+    await state.callbacks.onAudioSample({
+      audioSample,
+      trackId: samplesWithIndex.track.trackId
     });
-    await state.callbacks.onAudioSample(samplesWithIndex.track.trackId, audioSample);
   }
   if (samplesWithIndex.track.type === "video") {
     const nalUnitType = bytes[4] & 31;
@@ -11662,16 +11671,16 @@ var parseMdatSection = async (state) => {
         data: bytes,
         timestamp: cts,
         duration: duration2,
-        cts,
-        dts,
-        trackId: samplesWithIndex.track.trackId,
+        decodingTimestamp: dts,
         type: isKeyframe && !isRecoveryPoint ? "key" : "delta",
-        offset,
-        timescale
+        offset
       },
-      timescale
+      timescale: originalTimescale
+    });
+    await state.callbacks.onVideoSample({
+      videoSample,
+      trackId: samplesWithIndex.track.trackId
     });
-    await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, videoSample);
   }
   const jump = jumpMarks.find((j) => j.afterSampleWithOffset === offset);
   if (jump) {
@@ -12046,6 +12055,9 @@ var forwardMediaParserControllerPauseResume = ({
 };
 // src/parse-media.ts
 var parseMedia = (options) => {
+  if (!options) {
+    return Promise.reject(new Error("No options provided. See https://www.remotion.dev/media-parser for how to get started."));
+  }
   return internalParseMedia({
     fields: options.fields ?? null,
     logLevel: options.logLevel ?? "info",
@@ -12113,7 +12125,7 @@ var considerSeekBasedOnChunk = async ({
     await callback(sample);
     return;
   }
-  const timestamp = Math.min(sample.dts / sample.timescale, sample.cts / sample.timescale);
+  const timestamp = Math.min(sample.decodingTimestamp / WEBCODECS_TIMESCALE, sample.timestamp / WEBCODECS_TIMESCALE);
   if (timestamp > pendingSeek.targetTime && chunkIndex !== null && chunkIndex > 0) {
     m3uState.setNextSeekShouldSubtractChunks(playlistUrl, subtractChunks + 1);
     parentController.seek(pendingSeek.targetTime);
@@ -12847,17 +12859,14 @@ var getAudioSampleFromCbr = ({
   const nthFrame = Math.round((initialOffset - state.mediaSection.getMediaSectionAssertOnlyOne().start) / avgLength);
   const durationInSeconds = samplesPerFrame / sampleRate;
   const timeInSeconds = nthFrame * samplesPerFrame / sampleRate;
-  const timestamp = Math.round(timeInSeconds * 1e6);
-  const duration2 = Math.round(durationInSeconds * 1e6);
+  const timestamp = Math.floor(timeInSeconds * WEBCODECS_TIMESCALE);
+  const duration2 = Math.floor(durationInSeconds * WEBCODECS_TIMESCALE);
   const audioSample = {
     data,
-    cts: timestamp,
-    dts: timestamp,
+    decodingTimestamp: timestamp,
     duration: duration2,
     offset: initialOffset,
-    timescale: 1e6,
     timestamp,
-    trackId: 0,
     type: "key"
   };
   return { audioSample, timeInSeconds, durationInSeconds };
@@ -12894,17 +12903,14 @@ var getAudioSampleFromVbr = ({
     tableOfContents: info.xingData.tableOfContents
   });
   const durationInSeconds = samplesPerFrame / info.xingData.sampleRate;
-  const timestamp = Math.round(timeInSeconds * 1e6);
-  const duration2 = Math.round(durationInSeconds * 1e6);
+  const timestamp = Math.floor(timeInSeconds * WEBCODECS_TIMESCALE);
+  const duration2 = Math.floor(durationInSeconds * WEBCODECS_TIMESCALE);
   const audioSample = {
     data,
-    cts: timestamp,
-    dts: timestamp,
+    decodingTimestamp: timestamp,
     duration: duration2,
     offset: position,
-    timescale: 1e6,
     timestamp,
-    trackId: 0,
     type: "key"
   };
   return { timeInSeconds, audioSample, durationInSeconds };
@@ -12977,9 +12983,10 @@ var parseMpegHeader = async ({
         description: undefined,
         numberOfChannels,
         sampleRate,
-        timescale: 1e6,
+        originalTimescale: 1e6,
         trackId: 0,
-        startInSeconds: 0
+        startInSeconds: 0,
+        timescale: WEBCODECS_TIMESCALE
       },
       registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
       tracks: state.callbacks.tracks,
@@ -13016,7 +13023,10 @@ var parseMpegHeader = async ({
     offset: initialOffset,
     durationInSeconds
   });
-  await state.callbacks.onAudioSample(0, audioSample);
+  await state.callbacks.onAudioSample({
+    audioSample,
+    trackId: 0
+  });
 };
 
 // src/containers/mp3/seek/wait-until-syncword.ts
@@ -13092,11 +13102,12 @@ var getStrhForIndex = (structure, trackId) => {
 // src/containers/riff/convert-queued-sample-to-mediaparser-sample.ts
 var getKeyFrameOffsetAndPocs = ({
   state,
-  sample
+  sample,
+  trackId
 }) => {
   if (sample.type === "key") {
     const sampleOffset = state.riff.sampleCounter.getSampleCountForTrack({
-      trackId: sample.trackId
+      trackId
     });
     return {
       sampleOffsetAtKeyframe: sampleOffset,
@@ -13108,7 +13119,7 @@ var getKeyFrameOffsetAndPocs = ({
   if (!keyframeAtOffset) {
     throw new Error("no keyframe at offset");
   }
-  const sampleOffsetAtKeyframe = keyframeAtOffset.sampleCounts[sample.trackId];
+  const sampleOffsetAtKeyframe = keyframeAtOffset.sampleCounts[trackId];
   const pocsAtKeyframeOffset = state.riff.sampleCounter.getPocAtKeyframeOffset({
     keyframeOffset: keyframeAtOffset.positionInBytes
   });
@@ -13117,12 +13128,17 @@ var getKeyFrameOffsetAndPocs = ({
     pocsAtKeyframeOffset
   };
 };
-var convertQueuedSampleToMediaParserSample = (sample, state) => {
-  const strh = getStrhForIndex(state.structure.getRiffStructure(), sample.trackId);
+var convertQueuedSampleToMediaParserSample = ({
+  sample,
+  state,
+  trackId
+}) => {
+  const strh = getStrhForIndex(state.structure.getRiffStructure(), trackId);
   const samplesPerSecond = strh.rate / strh.scale;
   const { sampleOffsetAtKeyframe, pocsAtKeyframeOffset } = getKeyFrameOffsetAndPocs({
     sample,
-    state
+    state,
+    trackId
   });
   const indexOfPoc = pocsAtKeyframeOffset.findIndex((poc) => poc === sample.avc?.poc);
   if (indexOfPoc === -1) {
@@ -13134,8 +13150,7 @@ var convertQueuedSampleToMediaParserSample = (sample, state) => {
     sample: {
       ...sample,
       timestamp,
-      cts: timestamp,
-      dts: timestamp
+      decodingTimestamp: timestamp
     },
     timescale: 1
   });
@@ -13545,10 +13560,8 @@ var handleChunk = async ({
     const rawSample = {
       data,
       duration: 1 / samplesPerSecond,
-      trackId,
       type: keyOrDelta === "bidirectional" ? "delta" : keyOrDelta,
       offset,
-      timescale: samplesPerSecond,
       avc: info
     };
     const maxFramesInBuffer = state.avc.getMaxFramesInBuffer();
@@ -13565,14 +13578,29 @@ var handleChunk = async ({
         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 = convertQueuedSampleToMediaParserSample(releasedFrame, state);
-    state.riff.sampleCounter.onVideoSample(videoSample);
-    await state.callbacks.onVideoSample(trackId, videoSample);
+    const videoSample = 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) {
@@ -13587,24 +13615,21 @@ var handleChunk = async ({
       trackId
     });
     const timeInSec = nthSample / samplesPerSecond;
-    const timestamp = timeInSec;
+    const timestamp = Math.floor(timeInSec * WEBCODECS_TIMESCALE);
     const data = iterator.getSlice(ckSize);
-    const audioSample = convertAudioOrVideoSampleToWebCodecsTimestamps({
-      sample: {
-        cts: timestamp,
-        dts: timestamp,
-        data,
-        duration: undefined,
-        timestamp,
-        trackId,
-        type: "key",
-        offset,
-        timescale: samplesPerSecond
-      },
-      timescale: 1
-    });
+    const audioSample = {
+      decodingTimestamp: timestamp,
+      data,
+      duration: undefined,
+      timestamp,
+      type: "key",
+      offset
+    };
     state.riff.sampleCounter.onAudioSample(trackId, audioSample);
-    await state.callbacks.onAudioSample(trackId, audioSample);
+    await state.callbacks.onAudioSample({
+      audioSample,
+      trackId
+    });
   }
 };
 var parseMovi = async ({
@@ -13647,9 +13672,19 @@ var parseMediaSection = async (state) => {
 var parseRiffBody = async (state) => {
   const releasedFrame = state.riff.queuedBFrames.getReleasedFrame();
   if (releasedFrame) {
-    const converted = convertQueuedSampleToMediaParserSample(releasedFrame, state);
-    state.riff.sampleCounter.onVideoSample(converted);
-    await state.callbacks.onVideoSample(releasedFrame.trackId, converted);
+    const converted = 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) === "in-section") {
@@ -14027,13 +14062,14 @@ var handleAacPacket = async ({
       type: "audio",
       codecData: { type: "aac-config", data: codecPrivate2 },
       trackId: programId,
-      timescale: MPEG_TIMESCALE,
+      originalTimescale: MPEG_TIMESCALE,
       codecEnum: "aac",
       codec: mapAudioObjectTypeToCodecString(audioObjectType),
       description: codecPrivate2,
       numberOfChannels: channelConfiguration,
       sampleRate,
-      startInSeconds: 0
+      startInSeconds: 0,
+      timescale: WEBCODECS_TIMESCALE
     };
     await registerAudioTrack({
       track,
@@ -14045,21 +14081,21 @@ var handleAacPacket = async ({
     });
   }
   const sample = {
-    cts: streamBuffer.pesHeader.pts - transportStream.startOffset.getOffset(programId),
-    dts: (streamBuffer.pesHeader.dts ?? streamBuffer.pesHeader.pts) - transportStream.startOffset.getOffset(programId),
+    decodingTimestamp: (streamBuffer.pesHeader.dts ?? 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: MPEG_TIMESCALE
+    offset
   };
   const audioSample = convertAudioOrVideoSampleToWebCodecsTimestamps({
     sample,
     timescale: MPEG_TIMESCALE
   });
-  await sampleCallbacks.onAudioSample(programId, audioSample);
+  await sampleCallbacks.onAudioSample({
+    audioSample,
+    trackId: programId
+  });
   transportStream.lastEmittedSample.setLastEmittedSample(sample);
 };
 
@@ -14550,9 +14586,10 @@ var parseFmt = async ({
       codecEnum: format,
       numberOfChannels,
       sampleRate,
-      timescale: 1e6,
+      originalTimescale: 1e6,
       trackId: 0,
-      startInSeconds: 0
+      startInSeconds: 0,
+      timescale: WEBCODECS_TIMESCALE
     },
     container: "wav",
     registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
@@ -14652,19 +14689,19 @@ var parseMediaSection2 = async ({
   const data = iterator.getSlice(toRead);
   const audioSample = convertAudioOrVideoSampleToWebCodecsTimestamps({
     sample: {
-      cts: timestamp,
-      dts: timestamp,
+      decodingTimestamp: timestamp,
       data,
       duration: duration2,
       timestamp,
-      trackId: 0,
       type: "key",
-      offset,
-      timescale: 1e6
+      offset
     },
     timescale: 1
   });
-  await state.callbacks.onAudioSample(0, audioSample);
+  await state.callbacks.onAudioSample({
+    audioSample,
+    trackId: 0
+  });
   return null;
 };
 
@@ -14837,19 +14874,18 @@ var getSampleFromBlock = async ({
   if (codec.startsWith("V_")) {
     const partialVideoSample = {
       data: iterator.getSlice(remainingNow),
-      cts: timecodeInMicroseconds,
-      dts: timecodeInMicroseconds,
+      decodingTimestamp: timecodeInMicroseconds,
       duration: undefined,
-      trackId: trackNumber2,
       timestamp: timecodeInMicroseconds,
-      offset,
-      timescale
+      offset
     };
     if (keyframe === null) {
       iterator.destroy();
       return {
         type: "partial-video-sample",
-        partialVideoSample
+        partialVideoSample,
+        trackId: trackNumber2,
+        timescale: WEBCODECS_TIMESCALE
       };
     }
     await addAvcToTrackAndActivateTrackIfNecessary({
@@ -14870,25 +14906,26 @@ var getSampleFromBlock = async ({
     iterator.destroy();
     return {
       type: "video-sample",
-      videoSample: sample
+      videoSample: sample,
+      trackId: trackNumber2,
+      timescale: WEBCODECS_TIMESCALE
     };
   }
   if (codec.startsWith("A_")) {
     const audioSample = {
       data: iterator.getSlice(remainingNow),
-      trackId: trackNumber2,
       timestamp: timecodeInMicroseconds,
       type: "key",
       duration: undefined,
-      cts: timecodeInMicroseconds,
-      dts: timecodeInMicroseconds,
-      offset,
-      timescale
+      decodingTimestamp: timecodeInMicroseconds,
+      offset
     };
     iterator.destroy();
     return {
       type: "audio-sample",
-      audioSample
+      audioSample,
+      trackId: trackNumber2,
+      timescale: WEBCODECS_TIMESCALE
     };
   }
   iterator.destroy();
@@ -15049,7 +15086,10 @@ var postprocessEbml = async ({
       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([]),
@@ -15057,7 +15097,10 @@ var postprocessEbml = async ({
       };
     }
     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([]),
@@ -15093,7 +15136,10 @@ var postprocessEbml = async ({
         ...sample.partialVideoSample,
         type: hasReferenceBlock ? "delta" : "key"
       };
-      await callbacks.onVideoSample(sample.partialVideoSample.trackId, completeFrame);
+      await callbacks.onVideoSample({
+        videoSample: completeFrame,
+        trackId: sample.trackId
+      });
     }
     return {
       type: "BlockGroup",
@@ -16146,7 +16192,7 @@ var sampleSorter = ({
       if (!callback) {
         throw new Error("No callback found for audio sample");
       }
-      latestSample[src] = sample.dts;
+      latestSample[src] = sample.decodingTimestamp;
       await callback(sample);
     },
     addVideoSample: async (src, sample) => {
@@ -16154,7 +16200,7 @@ var sampleSorter = ({
       if (!callback) {
         throw new Error("No callback found for video sample.");
       }
-      latestSample[src] = sample.dts;
+      latestSample[src] = sample.decodingTimestamp;
       await callback(sample);
     },
     getNextStreamToRun: (streams) => {
@@ -16639,7 +16685,8 @@ var fetchIdx1 = async ({
   controller,
   position,
   logLevel,
-  prefetchCache
+  prefetchCache,
+  contentLength
 }) => {
   Log.verbose(logLevel, "Making request to fetch idx1 from ", src, "position", position);
   const result = await readerInterface.read({
@@ -16649,7 +16696,10 @@ var fetchIdx1 = async ({
     logLevel,
     prefetchCache
   });
-  const iterator = getArrayBufferIterator(new Uint8Array, Infinity);
+  if (result.contentLength === null) {
+    throw new Error("Content length is null");
+  }
+  const iterator = getArrayBufferIterator(new Uint8Array, contentLength - position + 1);
   while (true) {
     const res = await result.reader.reader.read();
     if (res.value) {
@@ -16679,7 +16729,8 @@ var lazyIdx1Fetch = ({
   logLevel,
   readerInterface,
   src,
-  prefetchCache
+  prefetchCache,
+  contentLength
 }) => {
   let prom = null;
   let result = null;
@@ -16696,7 +16747,8 @@ var lazyIdx1Fetch = ({
       position,
       readerInterface,
       src,
-      prefetchCache
+      prefetchCache,
+      contentLength
     }).then((entries) => {
       prom = null;
       result = entries;
@@ -16749,13 +16801,18 @@ var queuedBFramesState = () => {
     queuedFrames.length = 0;
   };
   return {
-    addFrame: (frame, maxFramesInBuffer) => {
+    addFrame: ({
+      frame,
+      maxFramesInBuffer,
+      trackId,
+      timescale
+    }) => {
       if (frame.type === "key") {
         flush();
-        releasedFrames.push(frame);
+        releasedFrames.push({ sample: frame, trackId, timescale });
         return;
       }
-      queuedFrames.push(frame);
+      queuedFrames.push({ sample: frame, trackId, timescale });
       if (queuedFrames.length > maxFramesInBuffer) {
         releasedFrames.push(queuedFrames.shift());
       }
@@ -16816,22 +16873,25 @@ var riffSampleCounter = () => {
     }
     samplesForTrack[trackId]++;
   };
-  const onVideoSample = (videoSample) => {
-    if (typeof samplesForTrack[videoSample.trackId] === "undefined") {
-      samplesForTrack[videoSample.trackId] = 0;
+  const onVideoSample = ({
+    trackId,
+    videoSample
+  }) => {
+    if (typeof samplesForTrack[trackId] === "undefined") {
+      samplesForTrack[trackId] = 0;
     }
     if (videoSample.type === "key") {
       riffKeys.addKeyframe({
-        trackId: videoSample.trackId,
-        decodingTimeInSeconds: videoSample.dts / videoSample.timescale,
+        trackId,
+        decodingTimeInSeconds: videoSample.decodingTimestamp / WEBCODECS_TIMESCALE,
         positionInBytes: videoSample.offset,
-        presentationTimeInSeconds: videoSample.cts / videoSample.timescale,
+        presentationTimeInSeconds: videoSample.timestamp / WEBCODECS_TIMESCALE,
         sizeInBytes: videoSample.data.length,
         sampleCounts: { ...samplesForTrack }
       });
     }
     if (videoSample.data.length > 0) {
-      samplesForTrack[videoSample.trackId]++;
+      samplesForTrack[trackId]++;
     }
   };
   const getSampleCountForTrack = ({ trackId }) => {
@@ -16884,7 +16944,8 @@ var riffSpecificState = ({
   logLevel,
   readerInterface,
   src,
-  prefetchCache
+  prefetchCache,
+  contentLength
 }) => {
   let avcProfile = null;
   let nextTrackIndex = 0;
@@ -16904,7 +16965,8 @@ var riffSpecificState = ({
     logLevel,
     readerInterface,
     src,
-    prefetchCache
+    prefetchCache,
+    contentLength
   });
   const sampleCounter = riffSampleCounter();
   const queuedBFrames = queuedBFramesState();
@@ -16963,7 +17025,10 @@ var callbacksState = ({
       }
       queuedVideoSamples[id] = [];
     },
-    onAudioSample: async (trackId, audioSample) => {
+    onAudioSample: async ({
+      audioSample,
+      trackId
+    }) => {
       if (controller._internals.signal.aborted) {
         throw new Error("Aborted");
       }
@@ -16981,7 +17046,10 @@ var callbacksState = ({
         samplesObserved.addAudioSample(audioSample);
       }
     },
-    onVideoSample: async (trackId, videoSample) => {
+    onVideoSample: async ({
+      trackId,
+      videoSample
+    }) => {
       if (controller._internals.signal.aborted) {
         throw new Error("Aborted");
       }
@@ -16998,9 +17066,9 @@ var callbacksState = ({
       if (videoSample.type === "key") {
         keyframes.addKeyframe({
           trackId,
-          decodingTimeInSeconds: videoSample.dts / videoSample.timescale,
+          decodingTimeInSeconds: videoSample.decodingTimestamp / WEBCODECS_TIMESCALE,
           positionInBytes: videoSample.offset,
-          presentationTimeInSeconds: videoSample.cts / videoSample.timescale,
+          presentationTimeInSeconds: videoSample.timestamp / WEBCODECS_TIMESCALE,
           sizeInBytes: videoSample.data.length
         });
       }
@@ -17055,9 +17123,9 @@ var samplesObservedState = () => {
     return largestSample - smallestSample;
   };
   const addVideoSample = (videoSample) => {
-    videoSamples.set(videoSample.cts, videoSample.data.byteLength);
-    const presentationTimeInSeconds = videoSample.cts / videoSample.timescale;
-    const duration2 = (videoSample.duration ?? 0) / videoSample.timescale;
+    videoSamples.set(videoSample.timestamp, videoSample.data.byteLength);
+    const presentationTimeInSeconds = videoSample.timestamp / WEBCODECS_TIMESCALE;
+    const duration2 = (videoSample.duration ?? 0) / WEBCODECS_TIMESCALE;
     if (largestVideoSample === undefined || presentationTimeInSeconds > largestVideoSample) {
       largestVideoSample = presentationTimeInSeconds + duration2;
     }
@@ -17066,9 +17134,9 @@ var samplesObservedState = () => {
     }
   };
   const addAudioSample = (audioSample) => {
-    audioSamples.set(audioSample.cts, audioSample.data.byteLength);
-    const presentationTimeInSeconds = audioSample.cts / audioSample.timescale;
-    const duration2 = (audioSample.duration ?? 0) / audioSample.timescale;
+    audioSamples.set(audioSample.timestamp, audioSample.data.byteLength);
+    const presentationTimeInSeconds = audioSample.timestamp / WEBCODECS_TIMESCALE;
+    const duration2 = (audioSample.duration ?? 0) / WEBCODECS_TIMESCALE;
     if (largestAudioSample === undefined || presentationTimeInSeconds > largestAudioSample) {
       largestAudioSample = presentationTimeInSeconds + duration2;
     }
@@ -17279,7 +17347,8 @@ var makeParserState = ({
       logLevel,
       readerInterface,
       src,
-      prefetchCache
+      prefetchCache,
+      contentLength
     }),
     transportStream: transportStreamState(),
     webm: webmState({
@@ -17436,6 +17505,9 @@ var internalParseMedia = async function({
   seekingHints,
   ...more
 }) {
+  if (!src) {
+    throw new Error('No "src" provided');
+  }
   controller._internals.markAsReadyToEmitEvents();
   warnIfRemotionLicenseNotAcknowledged({
     acknowledgeRemotionLicense,
@@ -17648,7 +17720,7 @@ var post = (message) => {
 };
 var controller = mediaParserController();
 var executeCallback = (payload) => {
-  const nonce = crypto.randomUUID();
+  const nonce = String(Math.random());
   const { promise, resolve, reject } = withResolvers();
   const cb = (msg) => {
     const data = msg.data;