@remotion/media-parser 4.0.237 → 4.0.239

package/dist/create/iso-base-media/create-iso-base-media.js

@@ -6,6 +6,7 @@ const log_1 = require("../../log");
 const create_ftyp_1 = require("./create-ftyp");
 const mp4_header_1 = require("./mp4-header");
 const primitives_1 = require("./primitives");
+const CONTAINER_TIMESCALE = 1000;
 const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, logLevel, filename, progressTracker, }) => {
     const header = (0, create_ftyp_1.createIsoBaseMediaFtyp)({
         compatibleBrands: ['isom', 'iso2', 'avc1', 'mp42'],
@@ -14,24 +15,26 @@ const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgr
     });
     const w = await writer.createContent({ filename, mimeType: 'video/mp4' });
     await w.write(header);
-    let durationInUnits = 0;
+    let globalDurationInUnits = 0;
+    const lowestTrackTimestamps = {};
+    const trackDurations = {};
     const currentTracks = [];
     const samplePositions = [];
     const sampleChunkIndices = [];
     const moovOffset = w.getWrittenByteCount();
     const getPaddedMoovAtom = () => {
         return (0, mp4_header_1.createPaddedMoovAtom)({
-            durationInUnits,
+            durationInUnits: globalDurationInUnits,
             trackInfo: currentTracks.map((track) => {
-                var _a;
+                var _a, _b;
                 return {
                     track,
-                    durationInUnits,
-                    samplePositions: (_a = samplePositions[track.trackNumber]) !== null && _a !== void 0 ? _a : [],
+                    durationInUnits: (_a = trackDurations[track.trackNumber]) !== null && _a !== void 0 ? _a : 0,
+                    samplePositions: (_b = samplePositions[track.trackNumber]) !== null && _b !== void 0 ? _b : [],
                     timescale: track.timescale,
                 };
             }),
-            timescale: 1000,
+            timescale: CONTAINER_TIMESCALE,
         });
     };
     await w.write(getPaddedMoovAtom());
@@ -52,10 +55,6 @@ const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgr
         await w.updateDataAt(moovOffset, getPaddedMoovAtom());
         onBytesProgress(w.getWrittenByteCount());
     };
-    const updateDuration = (newDuration) => {
-        durationInUnits = newDuration;
-        onMillisecondsProgress(newDuration);
-    };
     const addCodecPrivateToTrack = ({ trackNumber, codecPrivate, }) => {
         currentTracks.forEach((track) => {
             if (track.trackNumber === trackNumber) {
@@ -64,18 +63,39 @@ const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgr
         });
     };
     let lastChunkWasVideo = false;
-    const addSample = async ({ chunk, trackNumber, isVideo, timescale, codecPrivate, }) => {
-        var _a, _b;
+    const addSample = async ({ chunk, trackNumber, isVideo, codecPrivate, }) => {
+        var _a, _b, _c, _d;
         const position = w.getWrittenByteCount();
         await w.write(chunk.data);
         mdatSize += chunk.data.length;
         onBytesProgress(w.getWrittenByteCount());
+        progressTracker.setPossibleLowestTimestamp(Math.min(chunk.timestamp, (_a = chunk.cts) !== null && _a !== void 0 ? _a : Infinity, (_b = chunk.dts) !== null && _b !== void 0 ? _b : Infinity));
         progressTracker.updateTrackProgress(trackNumber, chunk.timestamp);
         if (codecPrivate) {
             addCodecPrivateToTrack({ trackNumber, codecPrivate });
         }
-        const newDuration = Math.round((chunk.timestamp + ((_a = chunk.duration) !== null && _a !== void 0 ? _a : 0)) / 1000);
-        updateDuration(newDuration);
+        const currentTrack = currentTracks.find((t) => t.trackNumber === trackNumber);
+        if (!currentTrack) {
+            throw new Error(`Tried to add sample to track ${trackNumber}, but it doesn't exist`);
+        }
+        if (!lowestTrackTimestamps[trackNumber] ||
+            chunk.timestamp < lowestTrackTimestamps[trackNumber]) {
+            lowestTrackTimestamps[trackNumber] = chunk.timestamp;
+        }
+        if (typeof lowestTrackTimestamps[trackNumber] !== 'number') {
+            throw new Error(`Tried to add sample to track ${trackNumber}, but it has no timestamp`);
+        }
+        const newDurationInMicroSeconds = chunk.timestamp +
+            ((_c = chunk.duration) !== null && _c !== void 0 ? _c : 0) -
+            lowestTrackTimestamps[trackNumber];
+        const newDurationInTrackTimeUnits = Math.round(newDurationInMicroSeconds / (1000000 / currentTrack.timescale));
+        trackDurations[trackNumber] = newDurationInTrackTimeUnits;
+        // webcodecs returns frame duration in microseconds
+        const newDurationInMilliseconds = Math.round((newDurationInMicroSeconds / 1000000) * CONTAINER_TIMESCALE);
+        if (newDurationInMilliseconds > globalDurationInUnits) {
+            globalDurationInUnits = newDurationInMilliseconds;
+            onMillisecondsProgress(newDurationInMilliseconds);
+        }
         if (!samplePositions[trackNumber]) {
             samplePositions[trackNumber] = [];
         }
@@ -99,9 +119,9 @@ const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgr
             isKeyframe: chunk.type === 'key',
             offset: position,
             chunk: sampleChunkIndices[trackNumber],
-            cts: Math.round(chunk.cts / (1000000 / timescale)),
-            dts: Math.round(chunk.dts / (1000000 / timescale)),
-            duration: Math.round(((_b = chunk.duration) !== null && _b !== void 0 ? _b : 0) / (1000000 / timescale)),
+            cts: Math.round((chunk.cts / 1000000) * currentTrack.timescale),
+            dts: Math.round((chunk.dts / 1000000) * currentTrack.timescale),
+            duration: Math.round((((_d = chunk.duration) !== null && _d !== void 0 ? _d : 0) / 1000000) * currentTrack.timescale),
             size: chunk.data.length,
         };
         lastChunkWasVideo = isVideo;
@@ -121,13 +141,12 @@ const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgr
         remove: async () => {
             await w.remove();
         },
-        addSample: ({ chunk, trackNumber, isVideo, timescale, codecPrivate }) => {
+        addSample: ({ chunk, trackNumber, isVideo, codecPrivate }) => {
             operationProm.current = operationProm.current.then(() => {
                 return addSample({
                     chunk,
                     trackNumber,
                     isVideo,
-                    timescale,
                     codecPrivate,
                 });
             });

package/dist/create/iso-base-media/trak/mdia/minf/create-stbl.js

@@ -12,10 +12,16 @@ const create_stsz_1 = require("./stbl/create-stsz");
 const create_stts_1 = require("./stbl/create-stts");
 const create_avc1_1 = require("./stbl/stsd/create-avc1");
 const createStbl = ({ samplePositions, codecSpecificData, isVideo, }) => {
+    // For stts:
+    // https://developer.apple.com/documentation/quicktime-file-format/time-to-sample_atom
+    // The sample entries are ordered by time stamps; therefore, the deltas are all nonnegative.
+    // For the other tables, there doesn't seem to be a requirement for them to be sorted
+    // -> ordering the sample positions by dts
+    const sorted = samplePositions.slice().sort((a, b) => a.dts - b.dts);
     return (0, primitives_1.addSize)((0, make_header_1.combineUint8Arrays)([
         (0, primitives_1.stringsToUint8Array)('stbl'),
         (0, create_avc1_1.createStsdData)(codecSpecificData),
-        (0, create_stts_1.createSttsAtom)(samplePositions),
+        (0, create_stts_1.createSttsAtom)(sorted),
         isVideo ? (0, create_stss_1.createStss)(samplePositions) : null,
         (0, create_ctts_1.createCttsBox)(samplePositions),
         (0, create_stsc_1.createStsc)(samplePositions),

package/dist/create/iso-base-media/trak/mdia/minf/stbl/create-stts.js

@@ -4,6 +4,9 @@ exports.createSttsAtom = void 0;
 const make_header_1 = require("../../../../../../boxes/webm/make-header");
 const primitives_1 = require("../../../../primitives");
 const makeEntry = (entry) => {
+    if (entry.sampleOffset < 0) {
+        throw new Error('negative sample offset in stts ' + entry.sampleOffset);
+    }
     return (0, make_header_1.combineUint8Arrays)([
         (0, primitives_1.numberTo32BitUIntOrInt)(entry.sampleCount),
         (0, primitives_1.numberTo32BitUIntOrInt)(entry.sampleOffset),

package/dist/create/media-fn.d.ts

@@ -10,7 +10,6 @@ export type MediaFn = {
         chunk: AudioOrVideoSample;
         trackNumber: number;
         isVideo: boolean;
-        timescale: number;
         codecPrivate: Uint8Array | null;
     }) => Promise<void>;
     addTrack: (track: Omit<MakeTrackAudio, 'trackNumber'> | Omit<MakeTrackVideo, 'trackNumber'>) => Promise<{

package/dist/create/progress-tracker.d.ts

@@ -3,5 +3,7 @@ export declare const makeProgressTracker: () => {
     getSmallestProgress: () => number;
     updateTrackProgress: (trackNumber: number, progress: number) => void;
     waitForProgress: () => Promise<void>;
+    getStartingTimestamp: () => number;
+    setPossibleLowestTimestamp: (timestamp: number) => void;
 };
 export type ProgressTracker = ReturnType<typeof makeProgressTracker>;

package/dist/create/progress-tracker.js

@@ -3,23 +3,45 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeProgressTracker = void 0;
 const event_emitter_1 = require("./event-emitter");
 const with_resolvers_1 = require("./with-resolvers");
+// Make sure to distinguish null and undefined here
 const makeProgressTracker = () => {
     const trackNumberProgresses = {};
     const eventEmitter = new event_emitter_1.IoEventEmitter();
-    const calculateSmallestProgress = () => {
-        const progressValues = Object.values(trackNumberProgresses);
-        if (progressValues.length === 0) {
-            return 0;
+    let startingTimestamp = null;
+    const setPossibleLowestTimestamp = (timestamp) => {
+        if (startingTimestamp === null) {
+            startingTimestamp = timestamp;
+        }
+        else {
+            startingTimestamp = Math.min(startingTimestamp, timestamp);
         }
+    };
+    const getStartingTimestamp = () => {
+        if (startingTimestamp === null) {
+            throw new Error('No starting timestamp');
+        }
+        return startingTimestamp;
+    };
+    const calculateSmallestProgress = () => {
+        const progressValues = Object.values(trackNumberProgresses).map((p) => {
+            if (p !== null) {
+                return p;
+            }
+            // The starting timestamp might not be 0, it might be very huge
+            // If no sample has arrived yet, we should assume the smallest value
+            // we know as the progress
+            if (startingTimestamp === null) {
+                throw new Error('No progress values to calculate smallest progress from');
+            }
+            return startingTimestamp;
+        });
         return Math.min(...progressValues);
     };
     return {
         registerTrack: (trackNumber) => {
-            trackNumberProgresses[trackNumber] = 0;
-        },
-        getSmallestProgress: () => {
-            return calculateSmallestProgress();
+            trackNumberProgresses[trackNumber] = null;
         },
+        getSmallestProgress: calculateSmallestProgress,
         updateTrackProgress: (trackNumber, progress) => {
             if (trackNumberProgresses[trackNumber] === undefined) {
                 throw new Error(`Tried to update progress for a track that was not registered: ${trackNumber}`);
@@ -38,6 +60,8 @@ const makeProgressTracker = () => {
             eventEmitter.addEventListener('processed', on);
             return promise;
         },
+        getStartingTimestamp,
+        setPossibleLowestTimestamp,
     };
 };
 exports.makeProgressTracker = makeProgressTracker;

package/dist/emit-available-info.js

@@ -84,7 +84,7 @@ const emitAvailableInfo = ({ hasInfo, parseResult, moreFields, state, returnValu
             if (returnValue.videoCodec === undefined &&
                 hasInfo.videoCodec &&
                 parseResult) {
-                const videoCodec = (0, get_video_codec_1.getVideoCodec)(parseResult.segments);
+                const videoCodec = (0, get_video_codec_1.getVideoCodec)(parseResult.segments, state);
                 (_g = moreFields.onVideoCodec) === null || _g === void 0 ? void 0 : _g.call(moreFields, videoCodec);
                 returnValue.videoCodec = videoCodec;
             }