@remotion/media-parser 4.0.290 → 4.0.292

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

@@ -0,0 +1,131 @@
+"use strict";
+/*
+  https://discord.com/channels/809501355504959528/1001500302375125055/1364798934832119870
+  Android 13 produces MP4 videos where first, all video samples are at the beginning,
+  then all audio samples are at the end.
+
+  This causes issues with our video decoder: "Waited too long for VideoDecoder" because
+  the overall progress is stuck.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateJumpMarks = void 0;
+// In WebCodecs, we require the tracks to deviate by at most 10 seconds
+// 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}`;
+};
+const findBestJump = ({ allSamplesSortedByOffset, 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)));
+    return firstSampleAboveMinProgress;
+};
+const calculateJumpMarks = (samplePositionTracks, endOfMdat) => {
+    const progresses = {};
+    for (const track of samplePositionTracks) {
+        progresses[track[0].track.trackId] = 0;
+    }
+    const jumpMarks = [];
+    const allSamplesSortedByOffset = samplePositionTracks
+        .flat(1)
+        .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) {
+            rollOverToProcess = true;
+            indexToVisit = 0;
+        }
+    };
+    let lastVisitedSample = null;
+    const addJumpMark = ({ firstSampleAboveMinProgress, }) => {
+        if (!lastVisitedSample) {
+            throw new Error('no last visited sample');
+        }
+        const jumpMark = {
+            afterSampleWithOffset: lastVisitedSample.samplePosition.offset,
+            jumpToOffset: allSamplesSortedByOffset[firstSampleAboveMinProgress].samplePosition
+                .offset,
+        };
+        indexToVisit = firstSampleAboveMinProgress;
+        jumpMarks.push(jumpMark);
+    };
+    const addFinalJumpIfNecessary = () => {
+        if (indexToVisit === allSamplesSortedByOffset.length - 1) {
+            return;
+        }
+        jumpMarks.push({
+            afterSampleWithOffset: allSamplesSortedByOffset[indexToVisit].samplePosition.offset,
+            jumpToOffset: endOfMdat,
+        });
+    };
+    const considerJump = () => {
+        const firstSampleAboveMinProgress = findBestJump({
+            allSamplesSortedByOffset,
+            visited,
+            progresses,
+        });
+        if (firstSampleAboveMinProgress > -1 &&
+            firstSampleAboveMinProgress !== indexToVisit + 1) {
+            addJumpMark({ firstSampleAboveMinProgress });
+            indexToVisit = firstSampleAboveMinProgress;
+        }
+        else {
+            while (true) {
+                increaseIndex();
+                if (!visited.has(getKey(allSamplesSortedByOffset[indexToVisit]))) {
+                    break;
+                }
+            }
+        }
+    };
+    while (true) {
+        const currentSamplePosition = allSamplesSortedByOffset[indexToVisit];
+        const sampleKey = getKey(currentSamplePosition);
+        if (visited.has(sampleKey)) {
+            considerJump();
+            continue;
+        }
+        visited.add(sampleKey);
+        if (rollOverToProcess) {
+            if (!lastVisitedSample) {
+                throw new Error('no last visited sample');
+            }
+            jumpMarks.push({
+                afterSampleWithOffset: lastVisitedSample.samplePosition.offset,
+                jumpToOffset: currentSamplePosition.samplePosition.offset,
+            });
+            rollOverToProcess = false;
+        }
+        lastVisitedSample = currentSamplePosition;
+        if (visited.size === allSamplesSortedByOffset.length) {
+            addFinalJumpIfNecessary();
+            break;
+        }
+        const timestamp = currentSamplePosition.samplePosition.dts /
+            currentSamplePosition.track.timescale;
+        progresses[currentSamplePosition.track.trackId] = timestamp;
+        const progressValues = Object.values(progresses);
+        const maxProgress = Math.max(...progressValues);
+        const minProgress = Math.min(...progressValues);
+        const spread = maxProgress - minProgress;
+        if (visited.size === allSamplesSortedByOffset.length) {
+            addFinalJumpIfNecessary();
+            break;
+        }
+        // Also don't allow audio progress to go more
+        if (spread > MAX_SPREAD_IN_SECONDS) {
+            considerJump();
+        }
+        else {
+            increaseIndex();
+        }
+    }
+    return jumpMarks;
+};
+exports.calculateJumpMarks = calculateJumpMarks;

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

@@ -1,3 +1,3 @@
-import type { Skip } from '../../../skip';
+import type { FetchMoreData, Skip } from '../../../skip';
 import type { ParserState } from '../../../state/parser-state';
-export declare const parseMdatSection: (state: ParserState) => Promise<Skip | null>;
+export declare const parseMdatSection: (state: ParserState) => Promise<Skip | FetchMoreData | null>;

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

@@ -8,6 +8,7 @@ const cached_sample_positions_1 = require("../../../state/iso-base-media/cached-
 const may_skip_video_data_1 = require("../../../state/may-skip-video-data");
 const video_section_1 = require("../../../state/video-section");
 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");
 const parseMdatSection = async (state) => {
     const mediaSection = (0, video_section_1.getCurrentMediaSection)({
@@ -37,9 +38,13 @@ const parseMdatSection = async (state) => {
         return (0, exports.parseMdatSection)(state);
     }
     if (!state.iso.flatSamples.getSamples(mediaSection.start)) {
-        state.iso.flatSamples.setSamples(mediaSection.start, (0, cached_sample_positions_1.calculateFlatSamples)(state));
+        const flattedSamples = (0, cached_sample_positions_1.calculateFlatSamples)(state);
+        const calcedJumpMarks = (0, calculate_jump_marks_1.calculateJumpMarks)(flattedSamples, endOfMdat);
+        state.iso.flatSamples.setJumpMarks(mediaSection.start, calcedJumpMarks);
+        state.iso.flatSamples.setSamples(mediaSection.start, flattedSamples.flat(1));
     }
     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();
@@ -59,8 +64,15 @@ const parseMdatSection = async (state) => {
         // iphonevideo.mov has extra padding here, so let's make sure to jump ahead
         return (0, skip_1.makeSkip)(endOfMdat);
     }
+    // Corrupt file: Sample is beyond the end of the file. Don't process it.
+    if (samplesWithIndex.samplePosition.offset +
+        samplesWithIndex.samplePosition.size >
+        state.contentLength) {
+        return (0, skip_1.makeSkip)(endOfMdat);
+    }
+    // Need to fetch more data
     if (iterator.bytesRemaining() < samplesWithIndex.samplePosition.size) {
-        return null;
+        return (0, skip_1.makeFetchMoreData)(samplesWithIndex.samplePosition.size - iterator.bytesRemaining());
     }
     const { cts, dts, duration, isKeyframe, offset, bigEndian, chunkSize } = samplesWithIndex.samplePosition;
     const bytes = (0, postprocess_bytes_1.postprocessBytes)({
@@ -114,6 +126,10 @@ const parseMdatSection = async (state) => {
         });
         await state.callbacks.onVideoSample(samplesWithIndex.track.trackId, videoSample);
     }
+    const jump = jumpMarks.find((j) => j.afterSampleWithOffset === offset);
+    if (jump) {
+        return (0, skip_1.makeSkip)(jump.jumpToOffset);
+    }
     return null;
 };
 exports.parseMdatSection = parseMdatSection;

package/dist/containers/iso-base-media/mfra/find-best-segment-from-tfra.d.ts

@@ -1,9 +1,9 @@
-import type { VideoTrack } from '../../../get-tracks';
+import type { AudioTrack, VideoTrack } from '../../../get-tracks';
 import type { IsoBaseMediaBox } from '../base-media-box';
-export declare const findBestSegmentFromTfra: ({ mfra, time, firstVideoTrack, timescale, }: {
+export declare const findBestSegmentFromTfra: ({ mfra, time, firstTrack, timescale, }: {
     mfra: IsoBaseMediaBox[];
     time: number;
-    firstVideoTrack: VideoTrack;
+    firstTrack: VideoTrack | AudioTrack;
     timescale: number;
 }) => {
     start: number;

package/dist/containers/iso-base-media/mfra/find-best-segment-from-tfra.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findBestSegmentFromTfra = void 0;
-const findBestSegmentFromTfra = ({ mfra, time, firstVideoTrack, timescale, }) => {
-    const tfra = mfra.find((b) => b.type === 'tfra-box' && b.trackId === firstVideoTrack.trackId);
+const findBestSegmentFromTfra = ({ mfra, time, firstTrack, timescale, }) => {
+    const tfra = mfra.find((b) => b.type === 'tfra-box' && b.trackId === firstTrack.trackId);
     if (!tfra) {
         return null;
     }

package/dist/containers/iso-base-media/mfra/get-mfra-atom.d.ts

@@ -1,12 +1,16 @@
 import type { MediaParserController } from '../../../controller/media-parser-controller';
+import type { PrefetchCache } from '../../../fetch';
+import type { LogLevel } from '../../../log';
 import type { ParseMediaSrc } from '../../../options';
 import type { ReaderInterface } from '../../../readers/reader';
-export declare const getMfraAtom: ({ src, contentLength, readerInterface, controller, parentSize, }: {
+export declare const getMfraAtom: ({ src, contentLength, readerInterface, controller, parentSize, logLevel, prefetchCache, }: {
     src: ParseMediaSrc;
     contentLength: number;
     readerInterface: ReaderInterface;
     controller: MediaParserController;
     parentSize: number;
+    logLevel: LogLevel;
+    prefetchCache: PrefetchCache;
 }) => Promise<{
     startReadingBits: () => void;
     stopReadingBits: () => void;

package/dist/containers/iso-base-media/mfra/get-mfra-atom.js

@@ -2,11 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMfraAtom = void 0;
 const buffer_iterator_1 = require("../../../iterator/buffer-iterator");
-const getMfraAtom = async ({ src, contentLength, readerInterface, controller, parentSize, }) => {
+const getMfraAtom = async ({ src, contentLength, readerInterface, controller, parentSize, logLevel, prefetchCache, }) => {
     const result = await readerInterface.read({
         controller,
         range: [contentLength - parentSize, contentLength - 1],
         src,
+        logLevel,
+        prefetchCache,
     });
     const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array(), parentSize);
     while (true) {

package/dist/containers/iso-base-media/mfra/get-mfro-atom.d.ts

@@ -1,9 +1,13 @@
 import type { MediaParserController } from '../../../controller/media-parser-controller';
+import type { PrefetchCache } from '../../../fetch';
+import type { LogLevel } from '../../../log';
 import type { ParseMediaSrc } from '../../../options';
 import type { ReaderInterface } from '../../../readers/reader';
-export declare const getMfroAtom: ({ src, contentLength, readerInterface, controller, }: {
+export declare const getMfroAtom: ({ src, contentLength, readerInterface, controller, logLevel, prefetchCache, }: {
     src: ParseMediaSrc;
     contentLength: number;
     readerInterface: ReaderInterface;
     controller: MediaParserController;
+    logLevel: LogLevel;
+    prefetchCache: PrefetchCache;
 }) => Promise<number | null>;

package/dist/containers/iso-base-media/mfra/get-mfro-atom.js

@@ -2,11 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMfroAtom = void 0;
 const buffer_iterator_1 = require("../../../iterator/buffer-iterator");
-const getMfroAtom = async ({ src, contentLength, readerInterface, controller, }) => {
+const getMfroAtom = async ({ src, contentLength, readerInterface, controller, logLevel, prefetchCache, }) => {
     const result = await readerInterface.read({
         controller,
         range: [contentLength - 16, contentLength - 1],
         src,
+        logLevel,
+        prefetchCache,
     });
     const { value } = await result.reader.reader.read();
     if (!value) {

package/dist/containers/iso-base-media/parse-boxes.js

@@ -25,8 +25,11 @@ const parseIsoBaseMedia = async (state) => {
         },
         contentLength: state.contentLength,
     });
-    if (result) {
-        state.structure.getIsoStructure().boxes.push(result);
+    if (result.type === 'fetch-more-data') {
+        return result.bytesNeeded;
+    }
+    if (result.type === 'box') {
+        state.structure.getIsoStructure().boxes.push(result.box);
     }
     return null;
 };

package/dist/containers/iso-base-media/process-box.d.ts

@@ -1,26 +1,37 @@
 import type { BufferIterator } from '../../iterator/buffer-iterator';
 import type { LogLevel } from '../../log';
+import type { FetchMoreData } from '../../skip';
 import type { TracksState } from '../../state/has-tracks-section';
 import type { IsoBaseMediaState } from '../../state/iso-base-media/iso-state';
-import type { SampleCallbacks } from '../../state/sample-callbacks';
+import type { CallbacksState } from '../../state/sample-callbacks';
 import type { MediaSectionState } from '../../state/video-section';
 import type { OnAudioTrack, OnVideoTrack } from '../../webcodec-sample-types';
-import type { BoxAndNext } from './base-media-box';
+import type { IsoBaseMediaBox } from './base-media-box';
 export type OnlyIfMoovAtomExpected = {
     tracks: TracksState;
     isoState: IsoBaseMediaState | null;
     onVideoTrack: OnVideoTrack | null;
     onAudioTrack: OnAudioTrack | null;
-    registerVideoSampleCallback: SampleCallbacks['registerVideoSampleCallback'];
-    registerAudioSampleCallback: SampleCallbacks['registerAudioSampleCallback'];
+    registerVideoSampleCallback: CallbacksState['registerVideoSampleCallback'];
+    registerAudioSampleCallback: CallbacksState['registerAudioSampleCallback'];
 };
 export type OnlyIfMdatAtomExpected = {
     mediaSectionState: MediaSectionState;
 };
+type ProcessBoxResult = {
+    type: 'box';
+    box: IsoBaseMediaBox;
+} | {
+    type: 'nothing';
+} | {
+    type: 'fetch-more-data';
+    bytesNeeded: FetchMoreData;
+};
 export declare const processBox: ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMdatAtomExpected, contentLength, }: {
     iterator: BufferIterator;
     logLevel: LogLevel;
     onlyIfMoovAtomExpected: OnlyIfMoovAtomExpected | null;
     onlyIfMdatAtomExpected: OnlyIfMdatAtomExpected | null;
     contentLength: number;
-}) => Promise<BoxAndNext>;
+}) => Promise<ProcessBoxResult>;
+export {};