@remotion/media-parser 4.0.279 → 4.0.282

package/dist/state/video-section.js

@@ -5,33 +5,61 @@
  * that can be read partially
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.videoSectionState = void 0;
-const videoSectionState = () => {
-    let videoSection = null;
-    const setVideoSection = (section) => {
-        videoSection = section;
-    };
-    const getVideoSection = () => {
-        if (!videoSection) {
-            throw new Error('No video section defined');
+exports.mediaSectionState = exports.getCurrentMediaSection = exports.isByteInMediaSection = void 0;
+const isByteInMediaSection = ({ position, mediaSections, }) => {
+    if (mediaSections.length === 0) {
+        return 'no-section-defined';
+    }
+    for (const section of mediaSections) {
+        if (position >= section.start && position < section.start + section.size) {
+            return 'in-section';
         }
-        return videoSection;
-    };
-    const isInVideoSectionState = (iterator) => {
-        if (!videoSection) {
-            return 'no-section-defined';
+    }
+    return 'outside-section';
+};
+exports.isByteInMediaSection = isByteInMediaSection;
+const getCurrentMediaSection = ({ offset, mediaSections, }) => {
+    for (const section of mediaSections) {
+        if (offset >= section.start && offset < section.start + section.size) {
+            return section;
+        }
+    }
+    return null;
+};
+exports.getCurrentMediaSection = getCurrentMediaSection;
+const mediaSectionState = () => {
+    const mediaSections = [];
+    const addMediaSection = (section) => {
+        // 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);
         }
+    };
+    const getMediaSections = () => {
+        return mediaSections;
+    };
+    const isCurrentByteInMediaSection = (iterator) => {
         const offset = iterator.counter.getOffset();
-        if (offset >= videoSection.start &&
-            offset < videoSection.start + videoSection.size) {
-            return 'in-section';
+        return (0, exports.isByteInMediaSection)({
+            position: offset,
+            mediaSections,
+        });
+    };
+    const getMediaSectionAssertOnlyOne = () => {
+        if (mediaSections.length !== 1) {
+            throw new Error('Expected only one video section');
         }
-        return 'outside-section';
+        return mediaSections[0];
     };
     return {
-        setVideoSection,
-        getVideoSection,
-        isInVideoSectionState,
+        addMediaSection,
+        getMediaSections,
+        isCurrentByteInMediaSection,
+        isByteInMediaSection: exports.isByteInMediaSection,
+        getCurrentMediaSection: exports.getCurrentMediaSection,
+        getMediaSectionAssertOnlyOne,
     };
 };
-exports.videoSectionState = videoSectionState;
+exports.mediaSectionState = mediaSectionState;

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

@@ -0,0 +1,3 @@
+import type { WorkOnSeekRequestOptions } from '../work-on-seek-request';
+import type { ParserState } from './parser-state';
+export declare const getWorkOnSeekRequestOptions: (state: ParserState) => WorkOnSeekRequestOptions;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorkOnSeekRequestOptions = void 0;
+const getWorkOnSeekRequestOptions = (state) => {
+    return {
+        logLevel: state.logLevel,
+        controller: state.controller,
+        isoState: state.iso,
+        iterator: state.iterator,
+        structureState: state.structure,
+        callbacks: state.callbacks,
+        src: state.src,
+        contentLength: state.contentLength,
+        readerInterface: state.readerInterface,
+        videoSection: state.videoSection,
+        mp4HeaderSegment: state.mp4HeaderSegment,
+        mode: state.mode,
+        seekInfiniteLoop: state.seekInfiniteLoop,
+        currentReader: state.currentReader,
+        discardReadBytes: state.discardReadBytes,
+        fields: state.fields,
+        onAudioTrack: state.onAudioTrack,
+        onVideoTrack: state.onVideoTrack,
+    };
+};
+exports.getWorkOnSeekRequestOptions = getWorkOnSeekRequestOptions;

package/dist/throttled-progress.d.ts

@@ -1,4 +1,4 @@
-import type { MediaParserController } from './media-parser-controller';
+import type { MediaParserController } from './controller/media-parser-controller';
 import type { ParseMediaOnProgress, ParseMediaProgress } from './options';
 export type ThrottledState = {
     get: () => ParseMediaProgress;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.279";
+export declare const VERSION = "4.0.282";

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.279';
+exports.VERSION = '4.0.282';

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

@@ -1,2 +1,43 @@
+import type { MediaParserController } from './controller/media-parser-controller';
+import type { AllOptions, ParseMediaFields } from './fields';
+import type { BufferIterator } from './iterator/buffer-iterator';
+import type { LogLevel } from './log';
+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 { IsoBaseMediaState } from './state/iso-base-media/iso-state';
 import type { ParserState } from './state/parser-state';
-export declare const workOnSeekRequest: (state: ParserState) => Promise<void>;
+import type { SeekInfiniteLoop } from './state/seek-infinite-loop';
+import type { StructureState } from './state/structure';
+import { type MediaSectionState } from './state/video-section';
+export type WorkOnSeekRequestOptions = {
+    logLevel: LogLevel;
+    controller: MediaParserController;
+    isoState: IsoBaseMediaState;
+    iterator: BufferIterator;
+    structureState: StructureState;
+    src: ParseMediaSrc;
+    contentLength: number;
+    readerInterface: ReaderInterface;
+    mediaSection: MediaSectionState;
+    mp4HeaderSegment: IsoBaseMediaStructure | null;
+    mode: ParseMediaMode;
+    seekInfiniteLoop: SeekInfiniteLoop;
+    currentReader: CurrentReader;
+    discardReadBytes: (force: boolean) => Promise<void>;
+    fields: Partial<AllOptions<ParseMediaFields>>;
+};
+export declare const getWorkOnSeekRequestOptions: (state: ParserState) => WorkOnSeekRequestOptions;
+export declare const workOnSeekRequest: (options: WorkOnSeekRequestOptions) => Promise<void>;
+export type SeekResolution = {
+    type: 'valid-but-must-wait';
+} | {
+    type: 'invalid';
+} | {
+    type: 'intermediary-seek';
+    byte: number;
+} | {
+    type: 'do-seek';
+    byte: number;
+};

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

@@ -1,43 +1,132 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.workOnSeekRequest = void 0;
+exports.workOnSeekRequest = exports.getWorkOnSeekRequestOptions = void 0;
 const get_seeking_info_1 = require("./get-seeking-info");
 const log_1 = require("./log");
 const perform_seek_1 = require("./perform-seek");
-const turnSeekIntoByte = (seek, state) => {
+const turnSeekIntoByte = async ({ seek, mediaSectionState, logLevel, iterator, structureState, mp4HeaderSegment, isoState, }) => {
+    const mediaSections = mediaSectionState.getMediaSections();
+    if (mediaSections.length === 0) {
+        log_1.Log.trace(logLevel, 'No video sections defined, cannot seek yet');
+        return {
+            type: 'valid-but-must-wait',
+        };
+    }
     if (seek.type === 'keyframe-before-time-in-seconds') {
-        const seekingInfo = (0, get_seeking_info_1.getSeekingInfo)(state);
+        const seekingInfo = (0, get_seeking_info_1.getSeekingInfo)({
+            structureState,
+            mp4HeaderSegment,
+            mediaSectionState,
+            isoState,
+        });
         if (!seekingInfo) {
+            log_1.Log.trace(logLevel, 'No seeking info, cannot seek yet');
             return {
                 type: 'valid-but-must-wait',
             };
         }
-        const seekingByte = (0, get_seeking_info_1.getSeekingByte)(seekingInfo, seek.time);
+        const seekingByte = await (0, get_seeking_info_1.getSeekingByte)({
+            info: seekingInfo,
+            time: seek.time,
+            logLevel,
+            currentPosition: iterator.counter.getOffset(),
+            isoState,
+        });
+        return seekingByte;
+    }
+    if (seek.type === 'byte') {
         return {
             type: 'do-seek',
-            byte: seekingByte,
+            byte: seek.byte,
         };
     }
-    throw new Error(`Cannot process seek request ${JSON.stringify(seek)}`);
+    throw new Error(`Cannot process seek request for ${seek}: ${JSON.stringify(seek)}`);
+};
+const getWorkOnSeekRequestOptions = (state) => {
+    return {
+        logLevel: state.logLevel,
+        controller: state.controller,
+        isoState: state.iso,
+        iterator: state.iterator,
+        structureState: state.structure,
+        src: state.src,
+        contentLength: state.contentLength,
+        readerInterface: state.readerInterface,
+        mediaSection: state.mediaSection,
+        mp4HeaderSegment: state.mp4HeaderSegment,
+        mode: state.mode,
+        seekInfiniteLoop: state.seekInfiniteLoop,
+        currentReader: state.currentReader,
+        discardReadBytes: state.discardReadBytes,
+        fields: state.fields,
+    };
 };
-const workOnSeekRequest = async (state) => {
-    const seek = state.controller._internals.seekSignal.getSeek();
+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 seek = controller._internals.seekSignal.getSeek();
     if (!seek) {
         return;
     }
-    log_1.Log.trace(state.logLevel, `Has seek request: ${JSON.stringify(seek)}`);
-    const resolution = turnSeekIntoByte(seek, state);
-    log_1.Log.trace(state.logLevel, `Seek action: ${JSON.stringify(resolution)}`);
+    log_1.Log.trace(logLevel, `Has seek request: ${JSON.stringify(seek)}`);
+    const resolution = await turnSeekIntoByte({
+        seek,
+        mediaSectionState: mediaSection,
+        logLevel,
+        iterator,
+        structureState,
+        mp4HeaderSegment,
+        isoState,
+    });
+    log_1.Log.trace(logLevel, `Seek action: ${JSON.stringify(resolution)}`);
+    if (resolution.type === 'intermediary-seek') {
+        await (0, perform_seek_1.performSeek)({
+            seekTo: resolution.byte,
+            userInitiated: false,
+            controller,
+            mediaSection,
+            iterator,
+            logLevel,
+            mode,
+            contentLength,
+            seekInfiniteLoop,
+            currentReader,
+            readerInterface,
+            src,
+            discardReadBytes,
+            fields,
+        });
+        return;
+    }
     if (resolution.type === 'do-seek') {
-        await (0, perform_seek_1.performSeek)({ state, seekTo: resolution.byte });
-        const { hasChanged } = state.controller._internals.seekSignal.clearSeekIfStillSame(seek);
+        await (0, perform_seek_1.performSeek)({
+            seekTo: resolution.byte,
+            userInitiated: true,
+            controller,
+            mediaSection,
+            iterator,
+            logLevel,
+            mode,
+            contentLength,
+            seekInfiniteLoop,
+            currentReader,
+            readerInterface,
+            src,
+            discardReadBytes,
+            fields,
+        });
+        const { hasChanged } = controller._internals.seekSignal.clearSeekIfStillSame(seek);
         if (hasChanged) {
-            log_1.Log.trace(state.logLevel, `Seek request has changed while seeking, seeking again`);
-            await (0, exports.workOnSeekRequest)(state);
+            log_1.Log.trace(logLevel, `Seek request has changed while seeking, seeking again`);
+            await (0, exports.workOnSeekRequest)(options);
         }
+        return;
     }
     if (resolution.type === 'invalid') {
         throw new Error(`The seek request ${JSON.stringify(seek)} cannot be processed`);
     }
+    if (resolution.type === 'valid-but-must-wait') {
+        log_1.Log.trace(logLevel, 'Seek request is valid but cannot be processed yet');
+    }
 };
 exports.workOnSeekRequest = workOnSeekRequest;

package/dist/worker/forward-controller.d.ts

@@ -1,3 +1,3 @@
-import type { MediaParserController } from '../media-parser-controller';
+import type { MediaParserController } from '../controller/media-parser-controller';
 import type { WorkerRequestPayload } from './worker-types';
 export declare const forwardMediaParserControllerToWorker: (controller: MediaParserController) => ((message: WorkerRequestPayload) => void);

package/dist/worker/forward-controller.js

@@ -8,6 +8,10 @@ const forwardMediaParserControllerToWorker = (controller) => {
             controller.pause();
             return;
         }
+        if (message.type === 'request-seek') {
+            controller._experimentalSeek(message.payload);
+            return;
+        }
         if (message.type === 'request-resume') {
             controller.resume();
             return;

package/dist/worker/worker-types.d.ts

@@ -1,5 +1,6 @@
 import type { M3uAssociatedPlaylist, M3uStream } from '../containers/m3u/get-streams';
 import type { SelectM3uAssociatedPlaylistsFnOptions, SelectM3uStreamFnOptions } from '../containers/m3u/select-stream';
+import type { Seek } from '../controller/seek-signal';
 import type { Dimensions, ImageType } from '../errors';
 import type { Options, ParseMediaFields } from '../fields';
 import type { MediaParserLocation } from '../get-location';
@@ -51,6 +52,10 @@ export type ParseMediaOnWorkerPayload = {
 type RequestPause = {
     type: 'request-pause';
 };
+type RequestSeek = {
+    type: 'request-seek';
+    payload: Seek;
+};
 type RequestResume = {
     type: 'request-resume';
 };
@@ -239,6 +244,6 @@ export type SignalErrorInCallback = {
     type: 'signal-error-in-callback';
     nonce: string;
 };
-export type WorkerRequestPayload = ParseMediaOnWorkerPayload | RequestResume | RequestPause | RequestAbort | AcknowledgeCallback | SignalErrorInCallback;
+export type WorkerRequestPayload = ParseMediaOnWorkerPayload | RequestResume | RequestPause | RequestAbort | RequestSeek | AcknowledgeCallback | SignalErrorInCallback;
 export type WorkerResponsePayload = ResponseDone | ResponseError | ResponseOnCallbackRequest;
 export {};

package/dist/worker-server.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.messageHandler = void 0;
 const select_stream_1 = require("./containers/m3u/select-stream");
+const media_parser_controller_1 = require("./controller/media-parser-controller");
 const internal_parse_media_1 = require("./internal-parse-media");
-const media_parser_controller_1 = require("./media-parser-controller");
 const forward_controller_1 = require("./worker/forward-controller");
 const serialize_error_1 = require("./worker/serialize-error");
 const post = (message) => {

package/dist/worker.module.d.ts

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

package/dist/worker.module.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMediaOnServerWorker = exports.parseMediaOnWebWorker = void 0;
+const parse_media_on_worker_entry_1 = require("./parse-media-on-worker-entry");
+const parseMediaOnWebWorker = (params) => {
+    return (0, parse_media_on_worker_entry_1.parseMediaOnWorkerImplementation)(params, new URL('./worker-web-entry', import.meta.url), 'parseMediaOnWebWorker');
+};
+exports.parseMediaOnWebWorker = parseMediaOnWebWorker;
+const parseMediaOnServerWorker = (params) => {
+    return (0, parse_media_on_worker_entry_1.parseMediaOnWorkerImplementation)(params, new URL('./worker-server-entry', import.meta.url), 'parseMediaOnServerWorker');
+};
+exports.parseMediaOnServerWorker = parseMediaOnServerWorker;

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.279",
+  "version": "4.0.282",
   "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.279",
-    "@remotion/eslint-config-internal": "4.0.279"
+    "@remotion/example-videos": "4.0.282",
+    "@remotion/eslint-config-internal": "4.0.282"
   },
   "publishConfig": {
     "access": "public"
@@ -68,6 +68,12 @@
       "require": "./dist/worker.js",
       "module": "./dist/esm/worker.mjs",
       "import": "./dist/esm/worker.mjs"
+    },
+    "./server-worker": {
+      "types": "./dist/server-worker.d.ts",
+      "require": "./dist/server-worker.js",
+      "module": "./dist/esm/server-worker.mjs",
+      "import": "./dist/esm/server-worker.mjs"
     }
   },
   "typesVersions": {
@@ -92,6 +98,9 @@
       ],
       "worker": [
         "./dist/worker.d.ts"
+      ],
+      "server-worker": [
+        "./dist/server-worker.d.ts"
       ]
     }
   },