@remotion/media-parser 4.0.326 → 4.0.329

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

@@ -65,6 +65,7 @@ const parseAac = async (state) => {
                 type: 'audio',
                 startInSeconds: 0,
                 timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
+                trackMediaTimeOffsetInTrackTimescale: 0,
             },
             registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
             tracks: state.callbacks.tracks,

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

@@ -46,6 +46,7 @@ const parseStreamInfo = async ({ iterator, state, }) => {
             trackId: 0,
             startInSeconds: 0,
             timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
+            trackMediaTimeOffsetInTrackTimescale: 0,
         },
         registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
         tracks: state.callbacks.tracks,

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

@@ -5,10 +5,12 @@ 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 normalize_video_rotation_1 = require("../../normalize-video-rotation");
 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");
+const get_editlist_1 = require("./mdat/get-editlist");
 const traversal_1 = require("./traversal");
 const makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
     var _a, _b, _c, _d, _e;
@@ -51,6 +53,9 @@ const makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
             codecEnum,
             startInSeconds: startTimeInSeconds,
             timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
+            trackMediaTimeOffsetInTrackTimescale: (0, get_editlist_1.findTrackMediaTimeOffsetInTrackTimescale)({
+                trakBox,
+            }),
         };
     }
     if (!(0, get_fps_1.trakBoxContainsVideo)(trakBox)) {
@@ -61,6 +66,9 @@ const makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
             trakBox,
             startInSeconds: startTimeInSeconds,
             timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
+            trackMediaTimeOffsetInTrackTimescale: (0, get_editlist_1.findTrackMediaTimeOffsetInTrackTimescale)({
+                trakBox,
+            }),
         };
     }
     const videoSample = (0, get_sample_aspect_ratio_1.getStsdVideoConfig)(trakBox);
@@ -103,7 +111,7 @@ const makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
         // Repeating those keys because they get picked up by VideoDecoder
         displayAspectWidth,
         displayAspectHeight,
-        rotation,
+        rotation: (0, normalize_video_rotation_1.normalizeVideoRotation)(0 - rotation),
         codecData: privateData,
         colorSpace: (0, color_to_webcodecs_colors_1.mediaParserAdvancedColorToWebCodecsColor)(advancedColor),
         advancedColor,
@@ -111,6 +119,9 @@ const makeBaseMediaTrack = (trakBox, startTimeInSeconds) => {
         fps: (0, get_fps_1.getFpsFromMp4TrakBox)(trakBox),
         startInSeconds: startTimeInSeconds,
         timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
+        trackMediaTimeOffsetInTrackTimescale: (0, get_editlist_1.findTrackMediaTimeOffsetInTrackTimescale)({
+            trakBox,
+        }),
     };
     return track;
 };

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

@@ -3,4 +3,9 @@ export type JumpMark = {
     afterSampleWithOffset: number;
     jumpToOffset: number;
 };
-export declare const calculateJumpMarks: (samplePositionTracks: MinimalFlatSampleForTesting[][], endOfMdat: number) => JumpMark[];
+export declare const calculateJumpMarks: ({ sampleMap, offsetsSorted, trackIds, endOfMdat, }: {
+    sampleMap: Map<number, MinimalFlatSampleForTesting>;
+    offsetsSorted: number[];
+    trackIds: number[];
+    endOfMdat: number;
+}) => JumpMark[];

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

@@ -15,30 +15,27 @@ const MAX_SPREAD_IN_SECONDS = 8;
 const getKey = (samplePositionTrack) => {
     return `${samplePositionTrack.track.trackId}-${samplePositionTrack.samplePosition.decodingTimestamp}`;
 };
-const findBestJump = ({ allSamplesSortedByOffset, visited, progresses, }) => {
+const findBestJump = ({ sampleMap, offsetsSorted, visited, progresses, }) => {
     var _a;
     const minProgress = Math.min(...Object.values(progresses));
     const trackNumberWithLowestProgress = (_a = Object.entries(progresses).find(([, progress]) => progress === minProgress)) === null || _a === void 0 ? void 0 : _a[0];
-    const firstSampleAboveMinProgress = allSamplesSortedByOffset.findIndex((sample) => sample.track.trackId === Number(trackNumberWithLowestProgress) &&
-        !visited.has(getKey(sample)));
+    const firstSampleAboveMinProgress = offsetsSorted.findIndex((offset) => sampleMap.get(offset).track.trackId ===
+        Number(trackNumberWithLowestProgress) &&
+        !visited.has(getKey(sampleMap.get(offset))));
     return firstSampleAboveMinProgress;
 };
-const calculateJumpMarks = (samplePositionTracks, endOfMdat) => {
+const calculateJumpMarks = ({ sampleMap, offsetsSorted, trackIds, endOfMdat, }) => {
     const progresses = {};
-    for (const track of samplePositionTracks) {
-        progresses[track[0].track.trackId] = 0;
+    for (const trackId of trackIds) {
+        progresses[trackId] = 0;
     }
     const jumpMarks = [];
-    const allSamplesSortedByOffset = samplePositionTracks
-        .flat(1)
-        .filter((s) => s.track.type === 'audio' || s.track.type === 'video')
-        .sort((a, b) => a.samplePosition.offset - b.samplePosition.offset);
     let indexToVisit = 0;
     const visited = new Set();
     let rollOverToProcess = false;
     const increaseIndex = () => {
         indexToVisit++;
-        if (indexToVisit >= allSamplesSortedByOffset.length) {
+        if (indexToVisit >= offsetsSorted.length) {
             rollOverToProcess = true;
             indexToVisit = 0;
         }
@@ -50,24 +47,24 @@ const calculateJumpMarks = (samplePositionTracks, endOfMdat) => {
         }
         const jumpMark = {
             afterSampleWithOffset: lastVisitedSample.samplePosition.offset,
-            jumpToOffset: allSamplesSortedByOffset[firstSampleAboveMinProgress].samplePosition
-                .offset,
+            jumpToOffset: offsetsSorted[firstSampleAboveMinProgress],
         };
         indexToVisit = firstSampleAboveMinProgress;
         jumpMarks.push(jumpMark);
     };
     const addFinalJumpIfNecessary = () => {
-        if (indexToVisit === allSamplesSortedByOffset.length - 1) {
+        if (indexToVisit === offsetsSorted.length - 1) {
             return;
         }
         jumpMarks.push({
-            afterSampleWithOffset: allSamplesSortedByOffset[indexToVisit].samplePosition.offset,
+            afterSampleWithOffset: offsetsSorted[indexToVisit],
             jumpToOffset: endOfMdat,
         });
     };
     const considerJump = () => {
         const firstSampleAboveMinProgress = findBestJump({
-            allSamplesSortedByOffset,
+            sampleMap,
+            offsetsSorted,
             visited,
             progresses,
         });
@@ -79,14 +76,14 @@ const calculateJumpMarks = (samplePositionTracks, endOfMdat) => {
         else {
             while (true) {
                 increaseIndex();
-                if (!visited.has(getKey(allSamplesSortedByOffset[indexToVisit]))) {
+                if (!visited.has(getKey(sampleMap.get(offsetsSorted[indexToVisit])))) {
                     break;
                 }
             }
         }
     };
     while (true) {
-        const currentSamplePosition = allSamplesSortedByOffset[indexToVisit];
+        const currentSamplePosition = sampleMap.get(offsetsSorted[indexToVisit]);
         const sampleKey = getKey(currentSamplePosition);
         if (visited.has(sampleKey)) {
             considerJump();
@@ -104,7 +101,7 @@ const calculateJumpMarks = (samplePositionTracks, endOfMdat) => {
             rollOverToProcess = false;
         }
         lastVisitedSample = currentSamplePosition;
-        if (visited.size === allSamplesSortedByOffset.length) {
+        if (visited.size === offsetsSorted.length) {
             addFinalJumpIfNecessary();
             break;
         }
@@ -115,7 +112,7 @@ const calculateJumpMarks = (samplePositionTracks, endOfMdat) => {
         const maxProgress = Math.max(...progressValues);
         const minProgress = Math.min(...progressValues);
         const spread = maxProgress - minProgress;
-        if (visited.size === allSamplesSortedByOffset.length) {
+        if (visited.size === offsetsSorted.length) {
             addFinalJumpIfNecessary();
             break;
         }

package/dist/containers/iso-base-media/mdat/get-editlist.d.ts

@@ -3,3 +3,6 @@ export declare const findTrackStartTimeInSeconds: ({ movieTimeScale, trakBox, }:
     movieTimeScale: number;
     trakBox: TrakBox;
 }) => number;
+export declare const findTrackMediaTimeOffsetInTrackTimescale: ({ trakBox, }: {
+    trakBox: TrakBox;
+}) => number;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findTrackStartTimeInSeconds = void 0;
+exports.findTrackMediaTimeOffsetInTrackTimescale = exports.findTrackStartTimeInSeconds = void 0;
 const traversal_1 = require("../traversal");
 const findTrackStartTimeInSeconds = ({ movieTimeScale, trakBox, }) => {
     const elstBox = (0, traversal_1.getElstBox)(trakBox);
@@ -19,3 +19,20 @@ const findTrackStartTimeInSeconds = ({ movieTimeScale, trakBox, }) => {
     return dwellTime / movieTimeScale;
 };
 exports.findTrackStartTimeInSeconds = findTrackStartTimeInSeconds;
+const findTrackMediaTimeOffsetInTrackTimescale = ({ trakBox, }) => {
+    const elstBox = (0, traversal_1.getElstBox)(trakBox);
+    if (!elstBox) {
+        return 0;
+    }
+    const { entries } = elstBox;
+    let dwellTime = 0;
+    for (const entry of entries) {
+        const { mediaTime } = entry;
+        if (mediaTime === -1) {
+            continue;
+        }
+        dwellTime += mediaTime;
+    }
+    return dwellTime;
+};
+exports.findTrackMediaTimeOffsetInTrackTimescale = findTrackMediaTimeOffsetInTrackTimescale;

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

@@ -9,6 +9,7 @@ const cached_sample_positions_1 = require("../../../state/iso-base-media/cached-
 const last_moof_box_1 = require("../../../state/iso-base-media/last-moof-box");
 const may_skip_video_data_1 = require("../../../state/may-skip-video-data");
 const video_section_1 = require("../../../state/video-section");
+const webcodecs_timescale_1 = require("../../../webcodecs-timescale");
 const get_moov_atom_1 = require("../get-moov-atom");
 const calculate_jump_marks_1 = require("./calculate-jump-marks");
 const postprocess_bytes_1 = require("./postprocess-bytes");
@@ -65,29 +66,33 @@ const parseMdatSection = async (state) => {
         return (0, exports.parseMdatSection)(state);
     }
     if (!state.iso.flatSamples.getSamples(mediaSection.start)) {
-        const flattedSamples = (0, cached_sample_positions_1.calculateFlatSamples)({
+        const { flatSamples: flatSamplesMap, offsets, trackIds, } = (0, cached_sample_positions_1.calculateFlatSamples)({
             state,
             mediaSectionStart: mediaSection.start,
         });
-        const calcedJumpMarks = (0, calculate_jump_marks_1.calculateJumpMarks)(flattedSamples, endOfMdat);
+        const calcedJumpMarks = (0, calculate_jump_marks_1.calculateJumpMarks)({
+            sampleMap: flatSamplesMap,
+            offsetsSorted: offsets,
+            trackIds,
+            endOfMdat,
+        });
         state.iso.flatSamples.setJumpMarks(mediaSection.start, calcedJumpMarks);
-        state.iso.flatSamples.setSamples(mediaSection.start, flattedSamples.flat(1));
+        state.iso.flatSamples.setSamples(mediaSection.start, flatSamplesMap);
     }
     const flatSamples = state.iso.flatSamples.getSamples(mediaSection.start);
     const jumpMarks = state.iso.flatSamples.getJumpMarks(mediaSection.start);
     const { iterator } = state;
-    const samplesWithIndex = flatSamples.find((sample) => {
-        return sample.samplePosition.offset === iterator.counter.getOffset();
-    });
+    const samplesWithIndex = flatSamples.get(iterator.counter.getOffset());
     if (!samplesWithIndex) {
         // There are various reasons why in mdat we find weird stuff:
         // - iphonevideo.hevc has a fake hoov atom which is not mapped
         // - corrupted.mp4 has a corrupt table
-        const nextSample_ = flatSamples
-            .filter((s) => s.samplePosition.offset > iterator.counter.getOffset())
-            .sort((a, b) => a.samplePosition.offset - b.samplePosition.offset)[0];
+        const offsets = Array.from(flatSamples.keys());
+        const nextSample_ = offsets
+            .filter((s) => s > iterator.counter.getOffset())
+            .sort((a, b) => a - b)[0];
         if (nextSample_) {
-            iterator.discard(nextSample_.samplePosition.offset - iterator.counter.getOffset());
+            iterator.discard(nextSample_ - iterator.counter.getOffset());
             return null;
         }
         // guess we reached the end!
@@ -108,9 +113,15 @@ const parseMdatSection = async (state) => {
         return (0, skip_1.makeFetchMoreData)(samplesWithIndex.samplePosition.size - iterator.bytesRemaining());
     }
     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 { originalTimescale, startInSeconds, trackMediaTimeOffsetInTrackTimescale, timescale: trackTimescale, } = samplesWithIndex.track;
+    const cts = rawCts +
+        startInSeconds * originalTimescale -
+        (trackMediaTimeOffsetInTrackTimescale / trackTimescale) *
+            webcodecs_timescale_1.WEBCODECS_TIMESCALE;
+    const dts = rawDts +
+        startInSeconds * originalTimescale -
+        (trackMediaTimeOffsetInTrackTimescale / trackTimescale) *
+            webcodecs_timescale_1.WEBCODECS_TIMESCALE;
     const bytes = (0, postprocess_bytes_1.postprocessBytes)({
         bytes: iterator.getSlice(samplesWithIndex.samplePosition.size),
         bigEndian,

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

@@ -70,6 +70,7 @@ const parseMpegHeader = async ({ state, }) => {
                 trackId: 0,
                 startInSeconds: 0,
                 timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
+                trackMediaTimeOffsetInTrackTimescale: 0,
             },
             registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
             tracks: state.callbacks.tracks,

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

@@ -31,6 +31,7 @@ const makeAviAudioTrack = ({ strf, index, }) => {
         trackId: index,
         startInSeconds: 0,
         timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
+        trackMediaTimeOffsetInTrackTimescale: 0,
     };
 };
 exports.makeAviAudioTrack = makeAviAudioTrack;
@@ -73,6 +74,7 @@ const makeAviVideoTrack = ({ strh, strf, index, }) => {
         fps: strh.rate / strh.scale,
         startInSeconds: 0,
         timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
+        trackMediaTimeOffsetInTrackTimescale: 0,
     };
 };
 exports.makeAviVideoTrack = makeAviVideoTrack;

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

@@ -40,6 +40,7 @@ const handleAacPacket = async ({ streamBuffer, programId, offset, sampleCallback
             sampleRate,
             startInSeconds: 0,
             timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
+            trackMediaTimeOffsetInTrackTimescale: 0,
         };
         await (0, register_track_1.registerAudioTrack)({
             track,

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

@@ -59,6 +59,7 @@ const handleAvcPacket = async ({ streamBuffer, programId, offset, sampleCallback
             advancedColor,
             startInSeconds: 0,
             timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
+            trackMediaTimeOffsetInTrackTimescale: 0,
         };
         await (0, register_track_1.registerVideoTrack)({
             track,

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

@@ -110,6 +110,7 @@ const parseFmt = async ({ state, }) => {
             trackId: 0,
             startInSeconds: 0,
             timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
+            trackMediaTimeOffsetInTrackTimescale: 0,
         },
         container: 'wav',
         registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,

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

@@ -273,6 +273,7 @@ const getTrack = ({ timescale, track, }) => {
             fps: null,
             startInSeconds: 0,
             timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
+            trackMediaTimeOffsetInTrackTimescale: 0,
         };
     }
     if ((0, track_entry_1.trackTypeToString)(trackType.value.value) === 'audio') {
@@ -301,6 +302,7 @@ const getTrack = ({ timescale, track, }) => {
             }),
             startInSeconds: 0,
             timescale: webcodecs_timescale_1.WEBCODECS_TIMESCALE,
+            trackMediaTimeOffsetInTrackTimescale: 0,
         };
     }
     return null;