@remotion/media-parser 4.0.303 → 4.0.305

package/dist/containers/aac/parse-aac.js

@@ -4,6 +4,7 @@ exports.parseAac = 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 parseAac = async (state) => {
     const { iterator } = state;
     const startOffset = iterator.counter.getOffset();
@@ -59,10 +60,11 @@ const parseAac = async (state) => {
                 description: codecPrivate,
                 numberOfChannels: channelConfiguration,
                 sampleRate,
-                timescale: 1000000,
+                originalTimescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
                 trackId: 0,
                 type: 'audio',
                 startInSeconds: 0,
+                timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
             },
             registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
             tracks: state.callbacks.tracks,
@@ -86,15 +88,15 @@ const parseAac = async (state) => {
             type: 'key',
             data,
             offset: startOffset,
-            timescale: 1000000,
-            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);
 };
 exports.parseAac = parseAac;

package/dist/containers/flac/parse-flac-frame.js

@@ -64,7 +64,7 @@ const parseFrameHeader = ({ iterator, state, }) => {
 };
 exports.parseFrameHeader = parseFrameHeader;
 const emitSample = async ({ state, data, offset, }) => {
-    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(data, null);
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(data, data.length);
     const parsed = (0, exports.parseFrameHeader)({ iterator, state });
     if (!parsed) {
         throw new Error('Invalid CRC');
@@ -89,17 +89,17 @@ const emitSample = async ({ state, data, offset, }) => {
         sample: {
             data,
             duration,
-            cts: timestamp,
-            dts: timestamp,
+            decodingTimestamp: timestamp,
             timestamp,
             type: 'key',
             offset,
-            timescale: 1,
-            trackId: 0,
         },
         timescale: 1,
     });
-    await state.callbacks.onAudioSample(0, audioSample);
+    await state.callbacks.onAudioSample({
+        audioSample,
+        trackId: 0,
+    });
     iterator.destroy();
 };
 const parseFlacFrame = async ({ state, iterator, }) => {

package/dist/containers/flac/parse-streaminfo.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseStreamInfo = void 0;
 const register_track_1 = require("../../register-track");
+const webcodecs_timescale_1 = require("../../webcodecs-timescale");
 const parseStreamInfo = async ({ iterator, state, }) => {
     const counter = iterator.counter.getOffset();
     const minimumBlockSize = iterator.getUint16();
@@ -41,9 +42,10 @@ const parseStreamInfo = async ({ iterator, state, }) => {
             codecEnum: 'flac',
             numberOfChannels: channels,
             sampleRate,
-            timescale: 1000000,
+            originalTimescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
             trackId: 0,
             startInSeconds: 0,
+            timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
         },
         registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
         tracks: state.callbacks.tracks,

package/dist/containers/iso-base-media/find-keyframe-before-time.js

@@ -6,8 +6,8 @@ const findKeyframeBeforeTime = ({ samplePositions, time, timescale, mediaSection
     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;
         }

package/dist/containers/iso-base-media/get-keyframes.js

@@ -21,7 +21,7 @@ const getKeyframesFromIsoBaseMedia = (state) => {
         return [];
     }
     const allSamples = videoTracks.map((t) => {
-        const { timescale: ts } = t;
+        const { originalTimescale: ts } = t;
         const trakBox = (0, traversal_1.getTrakBoxByTrackId)(moov, t.trackId);
         if (!trakBox) {
             return [];
@@ -44,8 +44,8 @@ const 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,
             };

package/dist/containers/iso-base-media/get-sample-position-bounds.js

@@ -6,8 +6,8 @@ const 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) +
+        const timestampMin = Math.min(samplePosition.timestamp, samplePosition.decodingTimestamp);
+        const timestampMax = Math.max(samplePosition.timestamp, samplePosition.decodingTimestamp) +
             ((_a = samplePosition.duration) !== null && _a !== void 0 ? _a : 0);
         if (timestampMin < min) {
             min = timestampMin;

package/dist/containers/iso-base-media/get-seeking-byte-from-fragmented-mp4.js

@@ -44,14 +44,14 @@ const getSeekingByteFromFragmentedMp4 = async ({ info, time, logLevel, currentPo
     });
     log_1.Log.trace(logLevel, 'Fragmented MP4 - Checking if we have seeking info for this time range');
     for (const positions of samplePositionsArray) {
-        const { min, max } = (0, get_sample_position_bounds_1.getSamplePositionBounds)(positions.samples, firstTrack.timescale);
+        const { min, max } = (0, get_sample_position_bounds_1.getSamplePositionBounds)(positions.samples, firstTrack.originalTimescale);
         if (min <= time &&
             (positions.isLastFragment || isLastChunkInPlaylist || time <= max)) {
             log_1.Log.trace(logLevel, `Fragmented MP4 - Found that we have seeking info for this time range: ${min} <= ${time} <= ${max}`);
             const kf = (0, find_keyframe_before_time_1.findKeyframeBeforeTime)({
                 samplePositions: positions.samples,
                 time,
-                timescale: firstTrack.timescale,
+                timescale: firstTrack.originalTimescale,
                 logLevel,
                 mediaSections: info.mediaSections,
                 startInSeconds: firstTrack.startInSeconds,
@@ -72,7 +72,7 @@ const getSeekingByteFromFragmentedMp4 = async ({ info, time, logLevel, currentPo
             mfra: atom,
             time,
             firstTrack,
-            timescale: firstTrack.timescale,
+            timescale: firstTrack.originalTimescale,
         });
         if (moofOffset !== null &&
             !(moofOffset.start <= currentPosition && currentPosition < moofOffset.end)) {

package/dist/containers/iso-base-media/get-seeking-byte.js

@@ -50,7 +50,7 @@ const getSeekingByteFromIsoBaseMedia = ({ info, time, logLevel, currentPosition,
     const keyframe = (0, find_keyframe_before_time_1.findKeyframeBeforeTime)({
         samplePositions,
         time,
-        timescale: track.timescale,
+        timescale: track.originalTimescale,
         logLevel,
         mediaSections: info.mediaSections,
         startInSeconds: track.startInSeconds,

package/dist/containers/iso-base-media/make-track.js

@@ -5,6 +5,7 @@ const get_audio_codec_1 = require("../../get-audio-codec");
 const get_fps_1 = require("../../get-fps");
 const get_sample_aspect_ratio_1 = require("../../get-sample-aspect-ratio");
 const get_video_codec_1 = require("../../get-video-codec");
+const webcodecs_timescale_1 = require("../../webcodecs-timescale");
 const color_to_webcodecs_colors_1 = require("./color-to-webcodecs-colors");
 const get_actual_number_of_channels_1 = require("./get-actual-number-of-channels");
 const get_video_codec_from_iso_track_1 = require("./get-video-codec-from-iso-track");
@@ -41,7 +42,7 @@ const makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
         return {
             type: 'audio',
             trackId: tkhdBox.trackId,
-            timescale: timescaleAndDuration.timescale,
+            originalTimescale: timescaleAndDuration.timescale,
             codec: codecString,
             numberOfChannels: actual.numberOfChannels,
             sampleRate: actual.sampleRate,
@@ -49,15 +50,17 @@ const makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
             codecData: actual.codecPrivate,
             codecEnum,
             startInSeconds: startTimeInSeconds,
+            timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
         };
     }
     if (!(0, get_fps_1.trakBoxContainsVideo)(trakBox)) {
         return {
             type: 'other',
             trackId: tkhdBox.trackId,
-            timescale: timescaleAndDuration.timescale,
+            originalTimescale: timescaleAndDuration.timescale,
             trakBox,
             startInSeconds: startTimeInSeconds,
+            timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
         };
     }
     const videoSample = (0, get_sample_aspect_ratio_1.getStsdVideoConfig)(trakBox);
@@ -90,7 +93,7 @@ const makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
         type: 'video',
         trackId: tkhdBox.trackId,
         description: videoDescriptors !== null && videoDescriptors !== void 0 ? videoDescriptors : undefined,
-        timescale: timescaleAndDuration.timescale,
+        originalTimescale: timescaleAndDuration.timescale,
         codec,
         sampleAspectRatio: (0, get_sample_aspect_ratio_1.getSampleAspectRatio)(trakBox),
         width,
@@ -107,6 +110,7 @@ const makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
         codecEnum: (0, get_video_codec_from_iso_track_1.getVideoCodecFromIsoTrak)(trakBox),
         fps: (0, get_fps_1.getFpsFromMp4TrakBox)(trakBox),
         startInSeconds: startTimeInSeconds,
+        timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
     };
     return track;
 };

package/dist/containers/iso-base-media/mdat/calculate-jump-marks.js

@@ -13,7 +13,7 @@ exports.calculateJumpMarks = void 0;
 // Therefore, we need to emit them to be less than 10 seconds apart
 const MAX_SPREAD_IN_SECONDS = 8;
 const getKey = (samplePositionTrack) => {
-    return `${samplePositionTrack.track.trackId}-${samplePositionTrack.samplePosition.dts}`;
+    return `${samplePositionTrack.track.trackId}-${samplePositionTrack.samplePosition.decodingTimestamp}`;
 };
 const findBestJump = ({ allSamplesSortedByOffset, visited, progresses, }) => {
     var _a;
@@ -107,8 +107,8 @@ const 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);

package/dist/containers/iso-base-media/mdat/mdat.js

@@ -107,10 +107,10 @@ const parseMdatSection = async (state) => {
     if (iterator.bytesRemaining() < samplesWithIndex.samplePosition.size) {
         return (0, skip_1.makeFetchMoreData)(samplesWithIndex.samplePosition.size - iterator.bytesRemaining());
     }
-    const { cts: rawCts, dts: rawDts, duration, isKeyframe, offset, bigEndian, chunkSize, } = samplesWithIndex.samplePosition;
-    const { timescale, startInSeconds } = samplesWithIndex.track;
-    const cts = rawCts + startInSeconds * timescale;
-    const dts = rawDts + startInSeconds * timescale;
+    const { timestamp: rawCts, decodingTimestamp: rawDts, duration, isKeyframe, offset, bigEndian, chunkSize, } = samplesWithIndex.samplePosition;
+    const { originalTimescale, startInSeconds } = samplesWithIndex.track;
+    const cts = rawCts + startInSeconds * originalTimescale;
+    const dts = rawDts + startInSeconds * originalTimescale;
     const bytes = (0, postprocess_bytes_1.postprocessBytes)({
         bytes: iterator.getSlice(samplesWithIndex.samplePosition.size),
         bigEndian,
@@ -122,16 +122,16 @@ const parseMdatSection = async (state) => {
                 data: bytes,
                 timestamp: cts,
                 duration,
-                cts,
-                dts,
-                trackId: samplesWithIndex.track.trackId,
+                decodingTimestamp: dts,
                 type: isKeyframe ? 'key' : 'delta',
                 offset,
-                timescale,
             },
-            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') {
         // https://remotion-assets.s3.eu-central-1.amazonaws.com/example-videos/sei_checkpoint.mp4
@@ -151,16 +151,16 @@ const parseMdatSection = async (state) => {
                 data: bytes,
                 timestamp: cts,
                 duration,
-                cts,
-                dts,
-                trackId: samplesWithIndex.track.trackId,
+                decodingTimestamp: dts,
                 type: isKeyframe && !isRecoveryPoint ? 'key' : 'delta',
                 offset,
-                timescale,
             },
-            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) {

package/dist/containers/iso-base-media/parse-icc-profile.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseIccProfile = void 0;
 const buffer_iterator_1 = require("../../iterator/buffer-iterator");
 const parseIccProfile = (data) => {
-    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(data, Infinity);
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(data, data.length);
     const size = iterator.getUint32();
     if (size !== data.length) {
         throw new Error('Invalid ICC profile size');
@@ -52,7 +52,7 @@ const parseIccProfile = (data) => {
             entry.tag === 'gXYZ' ||
             entry.tag === 'bXYZ' ||
             entry.tag === 'wtpt') {
-            const it = (0, buffer_iterator_1.getArrayBufferIterator)(found, Infinity);
+            const it = (0, buffer_iterator_1.getArrayBufferIterator)(found, found.length);
             it.discard(4);
             const x = it.getInt32() / 65536;
             const y = it.getInt32() / 65536;

package/dist/containers/m3u/first-sample-in-m3u-chunk.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.considerSeekBasedOnChunk = void 0;
+const webcodecs_timescale_1 = require("../../webcodecs-timescale");
 const considerSeekBasedOnChunk = async ({ sample, parentController, childController, callback, m3uState, playlistUrl, subtractChunks, chunkIndex, }) => {
     const pendingSeek = m3uState.getSeekToSecondsToProcess(playlistUrl);
     // If there is not even a seek to consider, just call the callback
@@ -8,7 +9,7 @@ const considerSeekBasedOnChunk = async ({ sample, parentController, childControl
         await callback(sample);
         return;
     }
-    const timestamp = Math.min(sample.dts / sample.timescale, sample.cts / sample.timescale);
+    const timestamp = Math.min(sample.decodingTimestamp / webcodecs_timescale_1.WEBCODECS_TIMESCALE, sample.timestamp / webcodecs_timescale_1.WEBCODECS_TIMESCALE);
     // Already too far, now we should go to the previous chunk
     if (timestamp > pendingSeek.targetTime &&
         chunkIndex !== null &&

package/dist/containers/m3u/sample-sorter.js

@@ -31,7 +31,7 @@ const sampleSorter = ({ logLevel, getAllChunksProcessedForPlaylist, }) => {
             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) => {
@@ -39,7 +39,7 @@ const sampleSorter = ({ logLevel, getAllChunksProcessedForPlaylist, }) => {
             if (!callback) {
                 throw new Error('No callback found for video sample.');
             }
-            latestSample[src] = sample.dts;
+            latestSample[src] = sample.decodingTimestamp;
             await callback(sample);
         },
         getNextStreamToRun: (streams) => {

package/dist/containers/mp3/parse-mpeg-header.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMpegHeader = void 0;
 const log_1 = require("../../log");
 const register_track_1 = require("../../register-track");
+const webcodecs_timescale_1 = require("../../webcodecs-timescale");
 const parse_packet_header_1 = require("./parse-packet-header");
 const parse_xing_1 = require("./parse-xing");
 const audio_sample_from_cbr_1 = require("./seek/audio-sample-from-cbr");
@@ -65,9 +66,10 @@ const parseMpegHeader = async ({ state, }) => {
                 description: undefined,
                 numberOfChannels,
                 sampleRate,
-                timescale: 1000000,
+                originalTimescale: 1000000,
                 trackId: 0,
                 startInSeconds: 0,
+                timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
             },
             registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
             tracks: state.callbacks.tracks,
@@ -106,6 +108,9 @@ const parseMpegHeader = async ({ state, }) => {
         offset: initialOffset,
         durationInSeconds,
     });
-    await state.callbacks.onAudioSample(0, audioSample);
+    await state.callbacks.onAudioSample({
+        audioSample,
+        trackId: 0,
+    });
 };
 exports.parseMpegHeader = parseMpegHeader;

package/dist/containers/mp3/seek/audio-sample-from-cbr.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAudioSampleFromCbr = void 0;
+const webcodecs_timescale_1 = require("../../../webcodecs-timescale");
 const get_frame_length_1 = require("../get-frame-length");
 const getAudioSampleFromCbr = ({ bitrateInKbit, initialOffset, layer, sampleRate, samplesPerFrame, data, state, }) => {
     const avgLength = (0, get_frame_length_1.getAverageMpegFrameLength)({
@@ -17,17 +18,14 @@ const getAudioSampleFromCbr = ({ bitrateInKbit, initialOffset, layer, sampleRate
         avgLength);
     const durationInSeconds = samplesPerFrame / sampleRate;
     const timeInSeconds = (nthFrame * samplesPerFrame) / sampleRate;
-    const timestamp = Math.round(timeInSeconds * 1000000);
-    const duration = Math.round(durationInSeconds * 1000000);
+    const timestamp = Math.round(timeInSeconds * webcodecs_timescale_1.WEBCODECS_TIMESCALE);
+    const duration = Math.round(durationInSeconds * webcodecs_timescale_1.WEBCODECS_TIMESCALE);
     const audioSample = {
         data,
-        cts: timestamp,
-        dts: timestamp,
+        decodingTimestamp: timestamp,
         duration,
         offset: initialOffset,
-        timescale: 1000000,
         timestamp,
-        trackId: 0,
         type: 'key',
     };
     return { audioSample, timeInSeconds, durationInSeconds };

package/dist/containers/mp3/seek/audio-sample-from-vbr.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAudioSampleFromVbr = void 0;
+const webcodecs_timescale_1 = require("../../../webcodecs-timescale");
 const get_duration_1 = require("../get-duration");
 const parse_xing_1 = require("../parse-xing");
 const samples_per_mpeg_file_1 = require("../samples-per-mpeg-file");
@@ -29,17 +30,14 @@ const getAudioSampleFromVbr = ({ info, position, mp3Info, data, }) => {
         tableOfContents: info.xingData.tableOfContents,
     });
     const durationInSeconds = samplesPerFrame / info.xingData.sampleRate;
-    const timestamp = Math.round(timeInSeconds * 1000000);
-    const duration = Math.round(durationInSeconds * 1000000);
+    const timestamp = Math.round(timeInSeconds * webcodecs_timescale_1.WEBCODECS_TIMESCALE);
+    const duration = Math.round(durationInSeconds * webcodecs_timescale_1.WEBCODECS_TIMESCALE);
     const audioSample = {
         data,
-        cts: timestamp,
-        dts: timestamp,
+        decodingTimestamp: timestamp,
         duration,
         offset: position,
-        timescale: 1000000,
         timestamp,
-        trackId: 0,
         type: 'key',
     };
     return { timeInSeconds, audioSample, durationInSeconds };

package/dist/containers/riff/convert-queued-sample-to-mediaparser-sample.d.ts

@@ -1,14 +1,15 @@
 import type { ParserState } from '../../state/parser-state';
 import type { QueuedVideoSample } from '../../state/riff/queued-frames';
-export declare const convertQueuedSampleToMediaParserSample: (sample: QueuedVideoSample, state: ParserState) => {
+export declare const convertQueuedSampleToMediaParserSample: ({ sample, state, trackId, }: {
+    sample: QueuedVideoSample;
+    state: ParserState;
+    trackId: number;
+}) => {
     timestamp: number;
-    cts: number;
-    dts: number;
+    decodingTimestamp: number;
     type: "key" | "delta";
     data: Uint8Array;
     duration: number | undefined;
-    trackId: number;
     offset: number;
-    timescale: number;
     avc?: import("../../webcodec-sample-types").MediaParserAvcExtraInfo | undefined;
 };

package/dist/containers/riff/convert-queued-sample-to-mediaparser-sample.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertQueuedSampleToMediaParserSample = void 0;
 const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
 const get_strh_for_index_1 = require("./get-strh-for-index");
-const getKeyFrameOffsetAndPocs = ({ state, sample, }) => {
+const getKeyFrameOffsetAndPocs = ({ state, sample, trackId, }) => {
     var _a, _b;
     if (sample.type === 'key') {
         const sampleOffset = state.riff.sampleCounter.getSampleCountForTrack({
-            trackId: sample.trackId,
+            trackId,
         });
         return {
             sampleOffsetAtKeyframe: sampleOffset,
@@ -19,7 +19,7 @@ const getKeyFrameOffsetAndPocs = ({ state, sample, }) => {
     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,
     });
@@ -28,12 +28,13 @@ const getKeyFrameOffsetAndPocs = ({ state, sample, }) => {
         pocsAtKeyframeOffset,
     };
 };
-const convertQueuedSampleToMediaParserSample = (sample, state) => {
-    const strh = (0, get_strh_for_index_1.getStrhForIndex)(state.structure.getRiffStructure(), sample.trackId);
+const convertQueuedSampleToMediaParserSample = ({ sample, state, trackId, }) => {
+    const strh = (0, get_strh_for_index_1.getStrhForIndex)(state.structure.getRiffStructure(), trackId);
     const samplesPerSecond = strh.rate / strh.scale;
     const { sampleOffsetAtKeyframe, pocsAtKeyframeOffset } = getKeyFrameOffsetAndPocs({
         sample,
         state,
+        trackId,
     });
     const indexOfPoc = pocsAtKeyframeOffset.findIndex((poc) => { var _a; return poc === ((_a = sample.avc) === null || _a === void 0 ? void 0 : _a.poc); });
     if (indexOfPoc === -1) {
@@ -45,8 +46,7 @@ const convertQueuedSampleToMediaParserSample = (sample, state) => {
         sample: {
             ...sample,
             timestamp,
-            cts: timestamp,
-            dts: timestamp,
+            decodingTimestamp: timestamp,
         },
         timescale: 1,
     });

package/dist/containers/riff/get-tracks-from-avi.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasAllTracksFromAvi = exports.getTracksFromAvi = exports.makeAviVideoTrack = exports.makeAviAudioTrack = exports.getNumberOfTracks = exports.TO_BE_OVERRIDDEN_LATER = void 0;
 const add_avc_profile_to_track_1 = require("../../add-avc-profile-to-track");
+const webcodecs_timescale_1 = require("../../webcodecs-timescale");
 const timescale_1 = require("./timescale");
 const traversal_1 = require("./traversal");
 exports.TO_BE_OVERRIDDEN_LATER = 'to-be-overriden-later';
@@ -26,9 +27,10 @@ const makeAviAudioTrack = ({ strf, index, }) => {
         description: new Uint8Array([18, 16]),
         numberOfChannels: strf.numberOfChannels,
         sampleRate: strf.sampleRate,
-        timescale: timescale_1.MEDIA_PARSER_RIFF_TIMESCALE,
+        originalTimescale: timescale_1.MEDIA_PARSER_RIFF_TIMESCALE,
         trackId: index,
         startInSeconds: 0,
+        timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
     };
 };
 exports.makeAviAudioTrack = makeAviAudioTrack;
@@ -46,7 +48,7 @@ const makeAviVideoTrack = ({ strh, strf, index, }) => {
         height: strf.height,
         type: 'video',
         displayAspectHeight: strf.height,
-        timescale: timescale_1.MEDIA_PARSER_RIFF_TIMESCALE,
+        originalTimescale: timescale_1.MEDIA_PARSER_RIFF_TIMESCALE,
         description: undefined,
         m3uStreamFormat: null,
         trackId: index,
@@ -70,6 +72,7 @@ const makeAviVideoTrack = ({ strh, strf, index, }) => {
         },
         fps: strh.rate / strh.scale,
         startInSeconds: 0,
+        timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
     };
 };
 exports.makeAviVideoTrack = makeAviVideoTrack;