@remotion/media-parser 4.0.290 → 4.0.291

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.290";
+export declare const VERSION = "4.0.291";

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.290';
+exports.VERSION = '4.0.291';

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

@@ -1,9 +1,9 @@
 import type { MediaParserController } from './controller/media-parser-controller';
+import type { PrefetchCache } from './fetch';
 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 { M3uPlaylistContext, ParseMediaMode, ParseMediaSrc } from './options';
 import type { ReaderInterface } from './readers/reader';
 import type { AacState } from './state/aac-state';
 import type { CurrentReader } from './state/current-reader';
@@ -11,6 +11,7 @@ import type { FlacState } from './state/flac-state';
 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 { M3uState } from './state/m3u-state';
 import type { WebmState } from './state/matroska/webm';
 import type { Mp3State } from './state/mp3';
 import type { ParserState } from './state/parser-state';
@@ -30,7 +31,7 @@ export type WorkOnSeekRequestOptions = {
     contentLength: number;
     readerInterface: ReaderInterface;
     mediaSection: MediaSectionState;
-    mp4HeaderSegment: IsoBaseMediaStructure | null;
+    m3uPlaylistContext: M3uPlaylistContext | null;
     transportStream: TransportStreamState;
     mode: ParseMediaMode;
     seekInfiniteLoop: SeekInfiniteLoop;
@@ -45,6 +46,8 @@ export type WorkOnSeekRequestOptions = {
     riffState: RiffState;
     mp3State: Mp3State;
     aacState: AacState;
+    m3uState: M3uState;
+    prefetchCache: PrefetchCache;
 };
 export declare const getWorkOnSeekRequestOptions: (state: ParserState) => WorkOnSeekRequestOptions;
 export declare const workOnSeekRequest: (options: WorkOnSeekRequestOptions) => Promise<void>;

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

@@ -5,7 +5,7 @@ const get_seeking_byte_1 = require("./get-seeking-byte");
 const get_seeking_hints_1 = require("./get-seeking-hints");
 const log_1 = require("./log");
 const perform_seek_1 = require("./perform-seek");
-const turnSeekIntoByte = async ({ seek, mediaSectionState, logLevel, iterator, structureState, mp4HeaderSegment, isoState, transportStream, tracksState, webmState, keyframes, flacState, samplesObserved, riffState, mp3State, contentLength, aacState, }) => {
+const turnSeekIntoByte = async ({ seek, mediaSectionState, logLevel, iterator, structureState, m3uPlaylistContext, isoState, transportStream, tracksState, webmState, keyframes, flacState, samplesObserved, riffState, mp3State, contentLength, aacState, m3uState, }) => {
     const mediaSections = mediaSectionState.getMediaSections();
     if (mediaSections.length === 0) {
         log_1.Log.trace(logLevel, 'No media sections defined, cannot seek yet');
@@ -21,7 +21,6 @@ const turnSeekIntoByte = async ({ seek, mediaSectionState, logLevel, iterator, s
             riffState,
             samplesObserved,
             structureState,
-            mp4HeaderSegment,
             mediaSectionState,
             isoState,
             transportStream,
@@ -32,6 +31,7 @@ const turnSeekIntoByte = async ({ seek, mediaSectionState, logLevel, iterator, s
             mp3State,
             contentLength,
             aacState,
+            m3uPlaylistContext,
         });
         if (!seekingHints) {
             log_1.Log.trace(logLevel, 'No seeking info, cannot seek yet');
@@ -48,18 +48,13 @@ const turnSeekIntoByte = async ({ seek, mediaSectionState, logLevel, iterator, s
             transportStream,
             webmState,
             mediaSection: mediaSectionState,
-            mp4HeaderSegment,
+            m3uPlaylistContext,
             structure: structureState,
             riffState,
+            m3uState,
         });
         return seekingByte;
     }
-    if (seek.type === 'byte') {
-        return {
-            type: 'do-seek',
-            byte: seek.byte,
-        };
-    }
     throw new Error(`Cannot process seek request for ${seek}: ${JSON.stringify(seek)}`);
 };
 const getWorkOnSeekRequestOptions = (state) => {
@@ -73,7 +68,7 @@ const getWorkOnSeekRequestOptions = (state) => {
         contentLength: state.contentLength,
         readerInterface: state.readerInterface,
         mediaSection: state.mediaSection,
-        mp4HeaderSegment: state.mp4HeaderSegment,
+        m3uPlaylistContext: state.m3uPlaylistContext,
         mode: state.mode,
         seekInfiniteLoop: state.seekInfiniteLoop,
         currentReader: state.currentReader,
@@ -88,23 +83,25 @@ const getWorkOnSeekRequestOptions = (state) => {
         riffState: state.riff,
         mp3State: state.mp3,
         aacState: state.aac,
+        m3uState: state.m3u,
+        prefetchCache: state.prefetchCache,
     };
 };
 exports.getWorkOnSeekRequestOptions = getWorkOnSeekRequestOptions;
 const workOnSeekRequest = async (options) => {
-    const { logLevel, controller, mediaSection, mp4HeaderSegment, isoState, iterator, structureState, src, contentLength, readerInterface, mode, seekInfiniteLoop, currentReader, discardReadBytes, fields, transportStream, tracksState, webmState, keyframes, flacState, samplesObserved, riffState, mp3State, aacState, } = options;
+    const { logLevel, controller, mediaSection, m3uPlaylistContext, isoState, iterator, structureState, src, contentLength, readerInterface, mode, seekInfiniteLoop, currentReader, discardReadBytes, fields, transportStream, tracksState, webmState, keyframes, flacState, samplesObserved, riffState, mp3State, aacState, prefetchCache, m3uState, } = options;
     const seek = controller._internals.seekSignal.getSeek();
     if (!seek) {
         return;
     }
-    log_1.Log.trace(logLevel, `Has seek request: ${JSON.stringify(seek)}`);
+    log_1.Log.trace(logLevel, `Has seek request for ${src}: ${JSON.stringify(seek)}`);
     const resolution = await turnSeekIntoByte({
         seek,
         mediaSectionState: mediaSection,
         logLevel,
         iterator,
         structureState,
-        mp4HeaderSegment,
+        m3uPlaylistContext,
         isoState,
         transportStream,
         tracksState,
@@ -116,6 +113,7 @@ const workOnSeekRequest = async (options) => {
         mp3State,
         contentLength,
         aacState,
+        m3uState,
     });
     log_1.Log.trace(logLevel, `Seek action: ${JSON.stringify(resolution)}`);
     if (resolution.type === 'intermediary-seek') {
@@ -134,6 +132,7 @@ const workOnSeekRequest = async (options) => {
             src,
             discardReadBytes,
             fields,
+            prefetchCache,
         });
         return;
     }
@@ -153,6 +152,7 @@ const workOnSeekRequest = async (options) => {
             src,
             discardReadBytes,
             fields,
+            prefetchCache,
         });
         const { hasChanged } = controller._internals.seekSignal.clearSeekIfStillSame(seek);
         if (hasChanged) {

package/dist/worker/forward-controller-to-worker.js

@@ -9,7 +9,7 @@ const forwardMediaParserControllerToWorker = (controller) => {
             return;
         }
         if (message.type === 'request-seek') {
-            controller._experimentalSeek(message.payload);
+            controller.seek(message.payload);
             return;
         }
         if (message.type === 'request-get-seeking-hints') {

package/dist/worker/serialize-error.js

@@ -4,7 +4,7 @@ exports.deserializeError = exports.serializeError = void 0;
 const errors_1 = require("../errors");
 const log_1 = require("../log");
 const serializeError = ({ error, logLevel, seekingHints, }) => {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g;
     if (error instanceof errors_1.IsAGifError) {
         return {
             type: 'response-error',
@@ -49,6 +49,22 @@ const serializeError = ({ error, logLevel, seekingHints, }) => {
             seekingHints,
         };
     }
+    if (error.name === 'AbortError') {
+        return {
+            type: 'response-error',
+            errorName: 'AbortError',
+            errorMessage: error.message,
+            errorStack: (_e = error.stack) !== null && _e !== void 0 ? _e : '',
+        };
+    }
+    if (error.name === 'NotReadableError') {
+        return {
+            type: 'response-error',
+            errorName: 'NotReadableError',
+            errorMessage: error.message,
+            errorStack: (_f = error.stack) !== null && _f !== void 0 ? _f : '',
+        };
+    }
     if (error.name !== 'Error') {
         log_1.Log.warn(logLevel, `Original error was of type ${error.name} did not properly propagate`);
     }
@@ -56,7 +72,7 @@ const serializeError = ({ error, logLevel, seekingHints, }) => {
         type: 'response-error',
         errorName: 'Error',
         errorMessage: error.message,
-        errorStack: (_e = error.stack) !== null && _e !== void 0 ? _e : '',
+        errorStack: (_g = error.stack) !== null && _g !== void 0 ? _g : '',
     };
 };
 exports.serializeError = serializeError;
@@ -94,8 +110,15 @@ const deserializeError = (error) => {
             });
         case 'MediaParserAbortError':
             return new errors_1.MediaParserAbortError(error.errorMessage);
-        default:
+        case 'Error':
             return new Error(error.errorMessage);
+        case 'AbortError':
+            return new Error(error.errorMessage);
+        // TODO: Document 2GB limit
+        case 'NotReadableError':
+            return new Error(error.errorMessage);
+        default:
+            throw new Error(`Unknown error name: ${error}`);
     }
 };
 exports.deserializeError = deserializeError;

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

@@ -79,9 +79,15 @@ type BaseError = {
     errorStack: string;
     errorMessage: string;
 };
+type AbortError = BaseError & {
+    errorName: 'AbortError';
+};
 type GenericError = BaseError & {
     errorName: 'Error';
 };
+type NotReadableError = BaseError & {
+    errorName: 'NotReadableError';
+};
 type IsAGifError = BaseError & {
     errorName: 'IsAGifError';
     mimeType: string | null;
@@ -112,7 +118,7 @@ type MediaParserAbortError = BaseError & {
     errorName: 'MediaParserAbortError';
     seekingHints: SeekingHints | null;
 };
-type AnyError = GenericError | IsAGifError | IsAnImageError | IsAPdfError | IsAnUnsupportedFileTypeError | MediaParserAbortError;
+type AnyError = GenericError | IsAGifError | IsAnImageError | IsAPdfError | IsAnUnsupportedFileTypeError | MediaParserAbortError | AbortError | NotReadableError;
 export type ResponseError = {
     type: 'response-error';
 } & AnyError;

package/dist/worker-server.js

@@ -42,7 +42,7 @@ const executeCallback = (payload) => {
 };
 const startParsing = async (message, reader) => {
     const { payload, src } = message;
-    const { fields, acknowledgeRemotionLicense, logLevel: userLogLevel, progressIntervalInMs, mp4HeaderSegment, seekingHints, makeSamplesStartAtZero, } = payload;
+    const { fields, acknowledgeRemotionLicense, logLevel: userLogLevel, progressIntervalInMs, m3uPlaylistContext, seekingHints, makeSamplesStartAtZero, } = payload;
     const { postAudioCodec, postContainer, postDimensions, postFps, postImages, postInternalStats, postIsHdr, postKeyframes, postLocation, postM3uStreams, postMetadata, postMimeType, postName, postNumberOfAudioChannels, postRotation, postSampleRate, postSlowAudioBitrate, postSlowNumberOfFrames, postSlowFps, postSlowDurationInSeconds, postSlowVideoBitrate, postStructure, postTracks, postUnrotatedDimensions, postVideoCodec, postSize, postSlowKeyframes, postDurationInSeconds, postParseProgress, postM3uStreamSelection, postM3uAssociatedPlaylistsSelection, postOnAudioTrack, postOnVideoTrack, } = message;
     const logLevel = userLogLevel !== null && userLogLevel !== void 0 ? userLogLevel : 'info';
     try {
@@ -301,7 +301,7 @@ const startParsing = async (message, reader) => {
                     return res.value;
                 }
                 : select_stream_1.defaultSelectM3uStreamFn,
-            mp4HeaderSegment: mp4HeaderSegment !== null && mp4HeaderSegment !== void 0 ? mp4HeaderSegment : null,
+            m3uPlaylistContext: m3uPlaylistContext !== null && m3uPlaylistContext !== void 0 ? m3uPlaylistContext : null,
             selectM3uAssociatedPlaylists: postM3uAssociatedPlaylistsSelection
                 ? async (playlists) => {
                     const res = await executeCallback({

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.290",
+  "version": "4.0.291",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
     "@types/wicg-file-system-access": "2023.10.5",
     "eslint": "9.19.0",
     "@types/bun": "1.2.8",
-    "@remotion/example-videos": "4.0.290",
-    "@remotion/eslint-config-internal": "4.0.290"
+    "@remotion/example-videos": "4.0.291",
+    "@remotion/eslint-config-internal": "4.0.291"
   },
   "publishConfig": {
     "access": "public"