@remotion/media-parser 4.0.285 → 4.0.286

package/dist/state/samples-observed/slow-duration-fps.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.samplesObservedState = void 0;
+const samplesObservedState = () => {
+    let smallestVideoSample;
+    let largestVideoSample;
+    let smallestAudioSample;
+    let largestAudioSample;
+    const videoSamples = new Map();
+    const audioSamples = new Map();
+    const getSlowVideoDurationInSeconds = () => {
+        let videoDuration = null;
+        if (smallestVideoSample !== undefined && largestVideoSample !== undefined) {
+            const startingTimestampDifference = largestVideoSample - smallestVideoSample;
+            const timeBetweenSamples = startingTimestampDifference / (videoSamples.size - 1);
+            videoDuration = timeBetweenSamples * videoSamples.size;
+        }
+        return videoDuration;
+    };
+    const getSlowDurationInSeconds = () => {
+        const videoDuration = getSlowVideoDurationInSeconds();
+        let audioDuration = null;
+        if (smallestAudioSample !== undefined && largestAudioSample !== undefined) {
+            const startingTimestampDifferenceAudio = largestAudioSample - smallestAudioSample;
+            const timeBetweenSamplesAudio = startingTimestampDifferenceAudio / (audioSamples.size - 1);
+            audioDuration = timeBetweenSamplesAudio * audioSamples.size;
+        }
+        if (videoDuration === null && audioDuration === null) {
+            throw new Error('No samples');
+        }
+        return Math.max(videoDuration !== null && videoDuration !== void 0 ? videoDuration : 0, audioDuration !== null && audioDuration !== void 0 ? audioDuration : 0);
+    };
+    const addVideoSample = (videoSample) => {
+        videoSamples.set(videoSample.cts, videoSample.data.byteLength);
+        const presentationTimeInSeconds = videoSample.cts / videoSample.timescale;
+        if (largestVideoSample === undefined ||
+            presentationTimeInSeconds > largestVideoSample) {
+            largestVideoSample = presentationTimeInSeconds;
+        }
+        if (smallestVideoSample === undefined ||
+            presentationTimeInSeconds < smallestVideoSample) {
+            smallestVideoSample = presentationTimeInSeconds;
+        }
+    };
+    const addAudioSample = (audioSample) => {
+        audioSamples.set(audioSample.cts, audioSample.data.byteLength);
+        const presentationTimeInSeconds = audioSample.cts / audioSample.timescale;
+        if (largestAudioSample === undefined ||
+            presentationTimeInSeconds > largestAudioSample) {
+            largestAudioSample = presentationTimeInSeconds;
+        }
+        if (smallestAudioSample === undefined ||
+            presentationTimeInSeconds < smallestAudioSample) {
+            smallestAudioSample = presentationTimeInSeconds;
+        }
+    };
+    const getFps = () => {
+        var _a;
+        const videoDuration = (_a = getSlowVideoDurationInSeconds()) !== null && _a !== void 0 ? _a : 0;
+        if (videoDuration === 0) {
+            return 0;
+        }
+        return videoSamples.size / videoDuration;
+    };
+    const getSlowNumberOfFrames = () => videoSamples.size;
+    const getAudioBitrate = () => {
+        const audioDuration = getSlowDurationInSeconds();
+        if (audioDuration === 0 || audioSamples.size === 0) {
+            return null;
+        }
+        const audioSizesInBytes = Array.from(audioSamples.values()).reduce((acc, size) => acc + size, 0);
+        return (audioSizesInBytes * 8) / audioDuration;
+    };
+    const getVideoBitrate = () => {
+        const videoDuration = getSlowDurationInSeconds();
+        if (videoDuration === 0 || videoSamples.size === 0) {
+            return null;
+        }
+        const videoSizesInBytes = Array.from(videoSamples.values()).reduce((acc, size) => acc + size, 0);
+        return (videoSizesInBytes * 8) / videoDuration;
+    };
+    return {
+        addVideoSample,
+        addAudioSample,
+        getSlowDurationInSeconds,
+        getFps,
+        getSlowNumberOfFrames,
+        getAudioBitrate,
+        getVideoBitrate,
+    };
+};
+exports.samplesObservedState = samplesObservedState;

package/dist/state/seek-infinite-loop.js

@@ -3,19 +3,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.seekInfiniteLoopDetectionState = void 0;
 const seekInfiniteLoopDetectionState = () => {
     let lastSeek = null;
+    let firstSeekTime = null;
     return {
         registerSeek: (byte) => {
+            const now = Date.now();
             if (!lastSeek || lastSeek.byte !== byte) {
                 lastSeek = { byte, numberOfTimes: 1 };
+                firstSeekTime = now;
                 return;
             }
             lastSeek.numberOfTimes++;
-            if (lastSeek.numberOfTimes >= 10) {
-                throw new Error(`Seeking infinite loop detected: Seeked to byte 0x${byte.toString(16)} ${lastSeek.numberOfTimes} times in a row with no position change in the file. Check your usage of .seek().`);
+            if (lastSeek.numberOfTimes >= 10 &&
+                firstSeekTime &&
+                now - firstSeekTime <= 2000) {
+                throw new Error(`Seeking infinite loop detected: Seeked to byte 0x${byte.toString(16)} ${lastSeek.numberOfTimes} times in a row in the last 2 seconds. Check your usage of .seek().`);
+            }
+            if (now - firstSeekTime > 2000) {
+                lastSeek = { byte, numberOfTimes: 1 };
+                firstSeekTime = now;
             }
         },
         reset: () => {
             lastSeek = null;
+            firstSeekTime = null;
         },
     };
 };

package/dist/state/transport-stream/observed-pes-header.d.ts

@@ -0,0 +1,13 @@
+import type { PacketPes } from '../../containers/transport-stream/parse-pes';
+export declare const makeObservedPesHeader: () => {
+    pesHeaders: PacketPes[];
+    addPesHeader: (pesHeader: PacketPes) => void;
+    markPtsAsKeyframe: (pts: number) => void;
+    getPesKeyframeHeaders: () => PacketPes[];
+};
+export type ObservedPesHeaderState = ReturnType<typeof makeObservedPesHeader>;
+export declare const getLastKeyFrameBeforeTimeInSeconds: ({ observedPesHeaders, timeInSeconds, ptsStartOffset, }: {
+    observedPesHeaders: ObservedPesHeaderState["pesHeaders"];
+    timeInSeconds: number;
+    ptsStartOffset: number;
+}) => PacketPes | undefined;

package/dist/state/transport-stream/observed-pes-header.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLastKeyFrameBeforeTimeInSeconds = exports.makeObservedPesHeader = void 0;
+const handle_avc_packet_1 = require("../../containers/transport-stream/handle-avc-packet");
+const makeObservedPesHeader = () => {
+    const pesHeaders = [];
+    const confirmedAsKeyframe = [];
+    const state = {
+        pesHeaders,
+        addPesHeader: (pesHeader) => {
+            if (pesHeaders.find((p) => p.offset === pesHeader.offset)) {
+                return;
+            }
+            pesHeaders.push(pesHeader);
+        },
+        markPtsAsKeyframe: (pts) => {
+            confirmedAsKeyframe.push(pts);
+        },
+        getPesKeyframeHeaders: () => {
+            return pesHeaders.filter((p) => confirmedAsKeyframe.includes(p.pts));
+        },
+    };
+    return state;
+};
+exports.makeObservedPesHeader = makeObservedPesHeader;
+const getLastKeyFrameBeforeTimeInSeconds = ({ observedPesHeaders, timeInSeconds, ptsStartOffset, }) => {
+    return observedPesHeaders.findLast((k) => (k.pts - ptsStartOffset) / handle_avc_packet_1.MPEG_TIMESCALE <= timeInSeconds);
+};
+exports.getLastKeyFrameBeforeTimeInSeconds = getLastKeyFrameBeforeTimeInSeconds;

package/dist/state/transport-stream/pts-start-offset.d.ts

@@ -0,0 +1,5 @@
+export declare const ptsStartOffsetStore: () => {
+    getOffset: (trackId: number) => number;
+    setOffset: (trackId: number, newOffset: number) => void;
+};
+export type PtsStartOffsetState = ReturnType<typeof ptsStartOffsetStore>;

package/dist/state/transport-stream/pts-start-offset.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ptsStartOffsetStore = void 0;
+const ptsStartOffsetStore = () => {
+    const offsets = {};
+    return {
+        getOffset: (trackId) => offsets[trackId] || 0,
+        setOffset: (trackId, newOffset) => {
+            offsets[trackId] = newOffset;
+        },
+    };
+};
+exports.ptsStartOffsetStore = ptsStartOffsetStore;

package/dist/state/transport-stream/start-offset.d.ts

@@ -1,4 +1,5 @@
-export declare const startOffsetStore: () => {
+export declare const ptsStartOffsetStore: () => {
     getOffset: (trackId: number) => number;
     setOffset: (trackId: number, newOffset: number) => void;
 };
+export type StartOffsetState = ReturnType<typeof ptsStartOffsetStore>;

package/dist/state/transport-stream/start-offset.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startOffsetStore = void 0;
-const startOffsetStore = () => {
+exports.ptsStartOffsetStore = void 0;
+const ptsStartOffsetStore = () => {
     const offsets = {};
     return {
         getOffset: (trackId) => offsets[trackId] || 0,
@@ -10,4 +10,4 @@ const startOffsetStore = () => {
         },
     };
 };
-exports.startOffsetStore = startOffsetStore;
+exports.ptsStartOffsetStore = ptsStartOffsetStore;

package/dist/state/transport-stream/transport-stream.d.ts

@@ -4,6 +4,12 @@ export declare const transportStreamState: () => {
         setNextPesHeader: (pesHeader: import("../../containers/transport-stream/parse-pes").PacketPes) => void;
         getNextPesHeader: () => import("../../containers/transport-stream/parse-pes").PacketPes;
     };
+    observedPesHeaders: {
+        pesHeaders: import("../../containers/transport-stream/parse-pes").PacketPes[];
+        addPesHeader: (pesHeader: import("../../containers/transport-stream/parse-pes").PacketPes) => void;
+        markPtsAsKeyframe: (pts: number) => void;
+        getPesKeyframeHeaders: () => import("../../containers/transport-stream/parse-pes").PacketPes[];
+    };
     streamBuffers: Map<number, TransportStreamPacketBuffer>;
     startOffset: {
         getOffset: (trackId: number) => number;

package/dist/state/transport-stream/transport-stream.js

@@ -3,13 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.transportStreamState = void 0;
 const last_emitted_sample_1 = require("./last-emitted-sample");
 const next_pes_header_store_1 = require("./next-pes-header-store");
-const start_offset_1 = require("./start-offset");
+const observed_pes_header_1 = require("./observed-pes-header");
+const pts_start_offset_1 = require("./pts-start-offset");
 const transportStreamState = () => {
     const streamBuffers = new Map();
-    const startOffset = (0, start_offset_1.startOffsetStore)();
+    const startOffset = (0, pts_start_offset_1.ptsStartOffsetStore)();
     const lastEmittedSample = (0, last_emitted_sample_1.lastEmittedSampleState)();
     const state = {
         nextPesHeaderStore: (0, next_pes_header_store_1.makeNextPesHeaderStore)(),
+        observedPesHeaders: (0, observed_pes_header_1.makeObservedPesHeader)(),
         streamBuffers,
         startOffset,
         resetBeforeSeek: () => {

package/dist/state/video-section.js

@@ -33,9 +33,21 @@ const mediaSectionState = () => {
         // Check if section overlaps with any existing sections
         const overlaps = mediaSections.some((existingSection) => section.start < existingSection.start + existingSection.size &&
             section.start + section.size > existingSection.start);
-        if (!overlaps) {
-            mediaSections.push(section);
+        if (overlaps) {
+            return;
         }
+        // Remove any existing sections that are encompassed by the new section
+        // Needed by Matroska because we need to define a 1 byte media section
+        // when seeking into a Cluster we have not seen yet
+        for (let i = mediaSections.length - 1; i >= 0; i--) {
+            const existingSection = mediaSections[i];
+            if (section.start <= existingSection.start &&
+                section.start + section.size >=
+                    existingSection.start + existingSection.size) {
+                mediaSections.splice(i, 1);
+            }
+        }
+        mediaSections.push(section);
     };
     const getMediaSections = () => {
         return mediaSections;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.285";
+export declare const VERSION = "4.0.286";

package/dist/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // Automatically generated on publish
-exports.VERSION = '4.0.285';
+exports.VERSION = '4.0.286';

package/dist/work-on-seek-request.d.ts

@@ -6,10 +6,14 @@ import type { ParseMediaMode, ParseMediaSrc } from './options';
 import type { IsoBaseMediaStructure } from './parse-result';
 import type { ReaderInterface } from './readers/reader';
 import type { CurrentReader } from './state/current-reader';
+import type { TracksState } from './state/has-tracks-section';
 import type { IsoBaseMediaState } from './state/iso-base-media/iso-state';
+import type { KeyframesState } from './state/keyframes';
+import type { WebmState } from './state/matroska/webm';
 import type { ParserState } from './state/parser-state';
 import type { SeekInfiniteLoop } from './state/seek-infinite-loop';
 import type { StructureState } from './state/structure';
+import type { TransportStreamState } from './state/transport-stream/transport-stream';
 import { type MediaSectionState } from './state/video-section';
 export type WorkOnSeekRequestOptions = {
     logLevel: LogLevel;
@@ -22,11 +26,15 @@ export type WorkOnSeekRequestOptions = {
     readerInterface: ReaderInterface;
     mediaSection: MediaSectionState;
     mp4HeaderSegment: IsoBaseMediaStructure | null;
+    transportStream: TransportStreamState;
     mode: ParseMediaMode;
     seekInfiniteLoop: SeekInfiniteLoop;
     currentReader: CurrentReader;
     discardReadBytes: (force: boolean) => Promise<void>;
     fields: Partial<AllOptions<ParseMediaFields>>;
+    tracksState: TracksState;
+    webmState: WebmState;
+    keyframes: KeyframesState;
 };
 export declare const getWorkOnSeekRequestOptions: (state: ParserState) => WorkOnSeekRequestOptions;
 export declare const workOnSeekRequest: (options: WorkOnSeekRequestOptions) => Promise<void>;

package/dist/work-on-seek-request.js

@@ -1,23 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.workOnSeekRequest = exports.getWorkOnSeekRequestOptions = void 0;
+const get_seeking_byte_1 = require("./get-seeking-byte");
 const get_seeking_info_1 = require("./get-seeking-info");
 const log_1 = require("./log");
 const perform_seek_1 = require("./perform-seek");
-const turnSeekIntoByte = async ({ seek, mediaSectionState, logLevel, iterator, structureState, mp4HeaderSegment, isoState, }) => {
+const turnSeekIntoByte = async ({ seek, mediaSectionState, logLevel, iterator, structureState, mp4HeaderSegment, isoState, transportStream, tracksState, webmState, keyframes, }) => {
     const mediaSections = mediaSectionState.getMediaSections();
     if (mediaSections.length === 0) {
-        log_1.Log.trace(logLevel, 'No video sections defined, cannot seek yet');
+        log_1.Log.trace(logLevel, 'No media sections defined, cannot seek yet');
         return {
             type: 'valid-but-must-wait',
         };
     }
-    if (seek.type === 'keyframe-before-time-in-seconds') {
+    if (seek.type === 'keyframe-before-time') {
+        if (seek.timeInSeconds < 0) {
+            throw new Error(`Cannot seek to a negative time: ${JSON.stringify(seek)}`);
+        }
         const seekingInfo = (0, get_seeking_info_1.getSeekingInfo)({
             structureState,
             mp4HeaderSegment,
             mediaSectionState,
             isoState,
+            transportStream,
+            tracksState,
         });
         if (!seekingInfo) {
             log_1.Log.trace(logLevel, 'No seeking info, cannot seek yet');
@@ -25,12 +31,16 @@ const turnSeekIntoByte = async ({ seek, mediaSectionState, logLevel, iterator, s
                 type: 'valid-but-must-wait',
             };
         }
-        const seekingByte = await (0, get_seeking_info_1.getSeekingByte)({
+        const seekingByte = await (0, get_seeking_byte_1.getSeekingByte)({
             info: seekingInfo,
-            time: seek.time,
+            time: seek.timeInSeconds,
             logLevel,
             currentPosition: iterator.counter.getOffset(),
             isoState,
+            transportStream,
+            webmState,
+            mediaSection: mediaSectionState,
+            keyframes,
         });
         return seekingByte;
     }
@@ -59,11 +69,15 @@ const getWorkOnSeekRequestOptions = (state) => {
         currentReader: state.currentReader,
         discardReadBytes: state.discardReadBytes,
         fields: state.fields,
+        transportStream: state.transportStream,
+        tracksState: state.callbacks.tracks,
+        webmState: state.webm,
+        keyframes: state.keyframes,
     };
 };
 exports.getWorkOnSeekRequestOptions = getWorkOnSeekRequestOptions;
 const workOnSeekRequest = async (options) => {
-    const { logLevel, controller, mediaSection, mp4HeaderSegment, isoState, iterator, structureState, src, contentLength, readerInterface, mode, seekInfiniteLoop, currentReader, discardReadBytes, fields, } = options;
+    const { logLevel, controller, mediaSection, mp4HeaderSegment, isoState, iterator, structureState, src, contentLength, readerInterface, mode, seekInfiniteLoop, currentReader, discardReadBytes, fields, transportStream, tracksState, webmState, keyframes, } = options;
     const seek = controller._internals.seekSignal.getSeek();
     if (!seek) {
         return;
@@ -77,6 +91,10 @@ const workOnSeekRequest = async (options) => {
         structureState,
         mp4HeaderSegment,
         isoState,
+        transportStream,
+        tracksState,
+        webmState,
+        keyframes,
     });
     log_1.Log.trace(logLevel, `Seek action: ${JSON.stringify(resolution)}`);
     if (resolution.type === 'intermediary-seek') {

package/dist/worker-server.js

@@ -357,6 +357,7 @@ const startParsing = async (message, reader) => {
                 }
                 : null,
             onDiscardedData: null,
+            makeSamplesStartAtZero: true,
         });
         post({
             type: 'response-done',

package/dist/worker.d.ts

@@ -1,4 +1,3 @@
 import type { ParseMediaOnWorker } from './options';
 export type { ParseMediaOnWorker, ParseMediaOnWorkerOptions } from './options';
 export declare const parseMediaOnWebWorker: ParseMediaOnWorker;
-export declare const parseMediaOnServerWorker: ParseMediaOnWorker;

package/package.json

@@ -3,15 +3,15 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.285",
+  "version": "4.0.286",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
     "@types/wicg-file-system-access": "2023.10.5",
     "eslint": "9.19.0",
-    "@types/bun": "1.2.5",
-    "@remotion/example-videos": "4.0.285",
-    "@remotion/eslint-config-internal": "4.0.285"
+    "@types/bun": "1.2.8",
+    "@remotion/example-videos": "4.0.286",
+    "@remotion/eslint-config-internal": "4.0.286"
   },
   "publishConfig": {
     "access": "public"