@remotion/media-parser 4.0.298 → 4.0.300

package/dist/webcodec-sample-types.d.ts

@@ -1,18 +1,29 @@
-import type { AudioTrack, VideoTrack } from './get-tracks';
+import type { MediaParserAudioTrack, MediaParserVideoTrack } from './get-tracks';
 import type { MediaParserContainer } from './options';
-export type OnAudioSample = (sample: AudioOrVideoSample) => void | Promise<void>;
-export type OnVideoSample = (sample: AudioOrVideoSample) => void | Promise<void>;
-export type OnAudioTrackParams = {
-    track: AudioTrack;
+export type MediaParserOnAudioSample = (sample: MediaParserAudioSample) => void | Promise<void>;
+export type MediaParserOnVideoSample = (sample: MediaParserVideoSample) => void | Promise<void>;
+export type MediaParserOnAudioTrackParams = {
+    track: MediaParserAudioTrack;
     container: MediaParserContainer;
 };
-export type OnAudioTrack = (options: OnAudioTrackParams) => OnAudioSample | Promise<OnAudioSample | null> | null;
-export type OnVideoTrackParams = {
-    track: VideoTrack;
+export type MediaParserOnAudioTrack = (options: MediaParserOnAudioTrackParams) => MediaParserOnAudioSample | Promise<MediaParserOnAudioSample | null> | null;
+export type MediaParserOnVideoTrackParams = {
+    track: MediaParserVideoTrack;
     container: MediaParserContainer;
 };
-export type OnVideoTrack = (options: OnVideoTrackParams) => OnVideoSample | Promise<OnVideoSample | null> | null;
-export type AudioOrVideoSample = {
+export type MediaParserOnVideoTrack = (options: MediaParserOnVideoTrackParams) => MediaParserOnVideoSample | Promise<MediaParserOnVideoSample | null> | null;
+export type MediaParserAudioSample = {
+    data: Uint8Array;
+    timestamp: number;
+    duration: number | undefined;
+    trackId: number;
+    type: 'key' | 'delta';
+    cts: number;
+    dts: number;
+    offset: number;
+    timescale: number;
+};
+export type MediaParserVideoSample = {
     data: Uint8Array;
     timestamp: number;
     duration: number | undefined;

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

@@ -2,9 +2,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 { MediaParserLogLevel } from './log';
 import type { M3uPlaylistContext, ParseMediaMode, ParseMediaSrc } from './options';
-import type { ReaderInterface } from './readers/reader';
+import type { MediaParserReaderInterface } from './readers/reader';
 import type { AacState } from './state/aac-state';
 import type { CurrentReader } from './state/current-reader';
 import type { FlacState } from './state/flac-state';
@@ -22,14 +22,14 @@ 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;
+    logLevel: MediaParserLogLevel;
     controller: MediaParserController;
     isoState: IsoBaseMediaState;
     iterator: BufferIterator;
     structureState: StructureState;
     src: ParseMediaSrc;
     contentLength: number;
-    readerInterface: ReaderInterface;
+    readerInterface: MediaParserReaderInterface;
     mediaSection: MediaSectionState;
     m3uPlaylistContext: M3uPlaylistContext | null;
     transportStream: TransportStreamState;

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

@@ -13,49 +13,46 @@ const turnSeekIntoByte = async ({ seek, mediaSectionState, logLevel, iterator, s
             type: 'valid-but-must-wait',
         };
     }
-    if (seek.type === 'keyframe-before-time') {
-        if (seek.timeInSeconds < 0) {
-            throw new Error(`Cannot seek to a negative time: ${JSON.stringify(seek)}`);
-        }
-        const seekingHints = (0, get_seeking_hints_1.getSeekingHints)({
-            riffState,
-            samplesObserved,
-            structureState,
-            mediaSectionState,
-            isoState,
-            transportStream,
-            tracksState,
-            keyframesState: keyframes,
-            webmState,
-            flacState,
-            mp3State,
-            contentLength,
-            aacState,
-            m3uPlaylistContext,
-        });
-        if (!seekingHints) {
-            log_1.Log.trace(logLevel, 'No seeking info, cannot seek yet');
-            return {
-                type: 'valid-but-must-wait',
-            };
-        }
-        const seekingByte = await (0, get_seeking_byte_1.getSeekingByte)({
-            info: seekingHints,
-            time: seek.timeInSeconds,
-            logLevel,
-            currentPosition: iterator.counter.getOffset(),
-            isoState,
-            transportStream,
-            webmState,
-            mediaSection: mediaSectionState,
-            m3uPlaylistContext,
-            structure: structureState,
-            riffState,
-            m3uState,
-        });
-        return seekingByte;
+    if (seek < 0) {
+        throw new Error(`Cannot seek to a negative time: ${JSON.stringify(seek)}`);
     }
-    throw new Error(`Cannot process seek request for ${seek}: ${JSON.stringify(seek)}`);
+    const seekingHints = (0, get_seeking_hints_1.getSeekingHints)({
+        riffState,
+        samplesObserved,
+        structureState,
+        mediaSectionState,
+        isoState,
+        transportStream,
+        tracksState,
+        keyframesState: keyframes,
+        webmState,
+        flacState,
+        mp3State,
+        contentLength,
+        aacState,
+        m3uPlaylistContext,
+    });
+    if (!seekingHints) {
+        log_1.Log.trace(logLevel, 'No seeking info, cannot seek yet');
+        return {
+            type: 'valid-but-must-wait',
+        };
+    }
+    const seekingByte = await (0, get_seeking_byte_1.getSeekingByte)({
+        info: seekingHints,
+        time: seek,
+        logLevel,
+        currentPosition: iterator.counter.getOffset(),
+        isoState,
+        transportStream,
+        webmState,
+        mediaSection: mediaSectionState,
+        m3uPlaylistContext,
+        structure: structureState,
+        riffState,
+        m3uState,
+    });
+    return seekingByte;
 };
 const getWorkOnSeekRequestOptions = (state) => {
     return {
@@ -91,7 +88,7 @@ exports.getWorkOnSeekRequestOptions = getWorkOnSeekRequestOptions;
 const workOnSeekRequest = async (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) {
+    if (seek === null) {
         return;
     }
     log_1.Log.trace(logLevel, `Has seek request for ${src}: ${JSON.stringify(seek)}`);

package/dist/worker/serialize-error.d.ts

@@ -1,9 +1,9 @@
-import type { LogLevel } from '../log';
+import type { MediaParserLogLevel } from '../log';
 import type { SeekingHints } from '../seeking-hints';
 import type { ResponseError } from './worker-types';
 export declare const serializeError: ({ error, logLevel, seekingHints, }: {
     error: Error;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     seekingHints: SeekingHints | null;
 }) => ResponseError;
 export declare const deserializeError: (error: ResponseError) => Error;

package/dist/worker/serialize-error.js

@@ -4,25 +4,14 @@ 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, _f, _g;
-    if (error instanceof errors_1.IsAGifError) {
-        return {
-            type: 'response-error',
-            errorName: 'IsAGifError',
-            errorMessage: error.message,
-            errorStack: (_a = error.stack) !== null && _a !== void 0 ? _a : '',
-            mimeType: error.mimeType,
-            sizeInBytes: error.sizeInBytes,
-            fileName: error.fileName,
-        };
-    }
+    var _a, _b, _c, _d, _e, _f;
     if (error instanceof errors_1.IsAnImageError) {
         return {
             type: 'response-error',
             errorName: 'IsAnImageError',
             dimensions: error.dimensions,
             errorMessage: error.message,
-            errorStack: (_b = error.stack) !== null && _b !== void 0 ? _b : '',
+            errorStack: (_a = error.stack) !== null && _a !== void 0 ? _a : '',
             fileName: error.fileName,
             imageType: error.imageType,
             mimeType: error.mimeType,
@@ -34,7 +23,7 @@ const serializeError = ({ error, logLevel, seekingHints, }) => {
             type: 'response-error',
             errorName: 'IsAPdfError',
             errorMessage: error.message,
-            errorStack: (_c = error.stack) !== null && _c !== void 0 ? _c : '',
+            errorStack: (_b = error.stack) !== null && _b !== void 0 ? _b : '',
             mimeType: error.mimeType,
             sizeInBytes: error.sizeInBytes,
             fileName: error.fileName,
@@ -45,7 +34,7 @@ const serializeError = ({ error, logLevel, seekingHints, }) => {
             type: 'response-error',
             errorName: 'MediaParserAbortError',
             errorMessage: error.message,
-            errorStack: (_d = error.stack) !== null && _d !== void 0 ? _d : '',
+            errorStack: (_c = error.stack) !== null && _c !== void 0 ? _c : '',
             seekingHints,
         };
     }
@@ -54,7 +43,7 @@ const serializeError = ({ error, logLevel, seekingHints, }) => {
             type: 'response-error',
             errorName: 'AbortError',
             errorMessage: error.message,
-            errorStack: (_e = error.stack) !== null && _e !== void 0 ? _e : '',
+            errorStack: (_d = error.stack) !== null && _d !== void 0 ? _d : '',
         };
     }
     if (error.name === 'NotReadableError') {
@@ -62,7 +51,7 @@ const serializeError = ({ error, logLevel, seekingHints, }) => {
             type: 'response-error',
             errorName: 'NotReadableError',
             errorMessage: error.message,
-            errorStack: (_f = error.stack) !== null && _f !== void 0 ? _f : '',
+            errorStack: (_e = error.stack) !== null && _e !== void 0 ? _e : '',
         };
     }
     if (error.name !== 'Error') {
@@ -72,19 +61,12 @@ const serializeError = ({ error, logLevel, seekingHints, }) => {
         type: 'response-error',
         errorName: 'Error',
         errorMessage: error.message,
-        errorStack: (_g = error.stack) !== null && _g !== void 0 ? _g : '',
+        errorStack: (_f = error.stack) !== null && _f !== void 0 ? _f : '',
     };
 };
 exports.serializeError = serializeError;
 const deserializeError = (error) => {
     switch (error.errorName) {
-        case 'IsAGifError':
-            return new errors_1.IsAGifError({
-                fileName: error.fileName,
-                mimeType: error.mimeType,
-                sizeInBytes: error.sizeInBytes,
-                message: error.errorMessage,
-            });
         case 'IsAnImageError':
             return new errors_1.IsAnImageError({
                 dimensions: error.dimensions,

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

@@ -1,17 +1,17 @@
 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 { ImageType } from '../errors';
 import type { Options, ParseMediaFields } from '../fields';
+import type { MediaParserDimensions } from '../get-dimensions';
 import type { MediaParserLocation } from '../get-location';
-import type { MediaParserAudioCodec, MediaParserVideoCodec } from '../get-tracks';
+import type { MediaParserAudioCodec, MediaParserTrack, MediaParserVideoCodec } from '../get-tracks';
 import type { MediaParserMetadataEntry } from '../metadata/get-metadata';
-import type { MediaParserContainer, MediaParserKeyframe, MediaParserTracks, ParseMediaProgress, ParseMediaResult, ParseMediaSrc, SerializeableOptionalParseMediaParams } from '../options';
+import type { MediaParserContainer, MediaParserKeyframe, ParseMediaProgress, ParseMediaResult, ParseMediaSrc, SerializeableOptionalParseMediaParams } from '../options';
 import type { MediaParserStructureUnstable } from '../parse-result';
 import type { SeekingHints } from '../seeking-hints';
 import type { MediaParserEmbeddedImage } from '../state/images';
 import type { InternalStats } from '../state/parser-state';
-import type { AudioOrVideoSample, OnAudioTrackParams, OnVideoTrackParams } from '../webcodec-sample-types';
+import type { MediaParserAudioSample, MediaParserOnAudioTrackParams, MediaParserOnVideoTrackParams, MediaParserVideoSample } from '../webcodec-sample-types';
 export type ParseMediaOnWorkerPayload = {
     type: 'request-worker';
     src: ParseMediaSrc;
@@ -41,7 +41,7 @@ export type ParseMediaOnWorkerPayload = {
     postSlowKeyframes: boolean;
     postSlowNumberOfFrames: boolean;
     postSlowVideoBitrate: boolean;
-    postStructure: boolean;
+    postSlowStructure: boolean;
     postTracks: boolean;
     postDurationInSeconds: boolean;
     postParseProgress: boolean;
@@ -55,7 +55,7 @@ type RequestPause = {
 };
 type RequestSeek = {
     type: 'request-seek';
-    payload: Seek;
+    payload: number;
 };
 type RequestResume = {
     type: 'request-resume';
@@ -88,16 +88,10 @@ type GenericError = BaseError & {
 type NotReadableError = BaseError & {
     errorName: 'NotReadableError';
 };
-type IsAGifError = BaseError & {
-    errorName: 'IsAGifError';
-    mimeType: string | null;
-    sizeInBytes: number | null;
-    fileName: string | null;
-};
 type IsAnImageError = BaseError & {
     errorName: 'IsAnImageError';
     imageType: ImageType;
-    dimensions: Dimensions | null;
+    dimensions: MediaParserDimensions | null;
     mimeType: string | null;
     sizeInBytes: number | null;
     fileName: string | null;
@@ -118,7 +112,7 @@ type MediaParserAbortError = BaseError & {
     errorName: 'MediaParserAbortError';
     seekingHints: SeekingHints | null;
 };
-type AnyError = GenericError | IsAGifError | IsAnImageError | IsAPdfError | IsAnUnsupportedFileTypeError | MediaParserAbortError | AbortError | NotReadableError;
+type AnyError = GenericError | IsAnImageError | IsAPdfError | IsAnUnsupportedFileTypeError | MediaParserAbortError | AbortError | NotReadableError;
 export type ResponseError = {
     type: 'response-error';
 } & AnyError;
@@ -130,10 +124,10 @@ export type ResponseCallbackPayload = {
     value: MediaParserContainer;
 } | {
     callbackType: 'dimensions';
-    value: Dimensions | null;
+    value: MediaParserDimensions | null;
 } | {
     callbackType: 'unrotated-dimensions';
-    value: Dimensions | null;
+    value: MediaParserDimensions | null;
 } | {
     callbackType: 'video-codec';
     value: MediaParserVideoCodec | null;
@@ -198,14 +192,14 @@ export type ResponseCallbackPayload = {
     callbackType: 'slow-video-bitrate';
     value: number | null;
 } | {
-    callbackType: 'structure';
+    callbackType: 'slow-structure';
     value: MediaParserStructureUnstable;
 } | {
     callbackType: 'tracks';
-    value: MediaParserTracks;
+    value: MediaParserTrack[];
 } | {
     callbackType: 'unrotated-dimensions';
-    value: Dimensions | null;
+    value: MediaParserDimensions | null;
 } | {
     callbackType: 'video-codec';
     value: MediaParserVideoCodec | null;
@@ -220,13 +214,17 @@ export type ResponseCallbackPayload = {
     value: SelectM3uStreamFnOptions;
 } | {
     callbackType: 'on-audio-track';
-    value: OnAudioTrackParams;
+    value: MediaParserOnAudioTrackParams;
 } | {
     callbackType: 'on-video-track';
-    value: OnVideoTrackParams;
+    value: MediaParserOnVideoTrackParams;
+} | {
+    callbackType: 'on-audio-sample';
+    value: MediaParserAudioSample;
+    trackId: number;
 } | {
-    callbackType: 'on-audio-video-sample';
-    value: AudioOrVideoSample;
+    callbackType: 'on-video-sample';
+    value: MediaParserVideoSample;
     trackId: number;
 } | {
     callbackType: 'm3u-associated-playlists-selection';

package/dist/worker-server.d.ts

@@ -1,2 +1,2 @@
-import type { ReaderInterface } from './readers/reader';
-export declare const messageHandler: (message: MessageEvent, readerInterface: ReaderInterface) => void;
+import type { MediaParserReaderInterface } from './readers/reader';
+export declare const messageHandler: (message: MessageEvent, readerInterface: MediaParserReaderInterface) => void;

package/dist/worker-server.js

@@ -43,7 +43,7 @@ const executeCallback = (payload) => {
 const startParsing = async (message, reader) => {
     const { payload, src } = message;
     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 { postAudioCodec, postContainer, postDimensions, postFps, postImages, postInternalStats, postIsHdr, postKeyframes, postLocation, postM3uStreams, postMetadata, postMimeType, postName, postNumberOfAudioChannels, postRotation, postSampleRate, postSlowAudioBitrate, postSlowNumberOfFrames, postSlowFps, postSlowDurationInSeconds, postSlowVideoBitrate, postSlowStructure, postTracks, postUnrotatedDimensions, postVideoCodec, postSize, postSlowKeyframes, postDurationInSeconds, postParseProgress, postM3uStreamSelection, postM3uAssociatedPlaylistsSelection, postOnAudioTrack, postOnVideoTrack, } = message;
     const logLevel = userLogLevel !== null && userLogLevel !== void 0 ? userLogLevel : 'info';
     try {
         const ret = await (0, internal_parse_media_1.internalParseMedia)({
@@ -240,10 +240,10 @@ const startParsing = async (message, reader) => {
                     });
                 }
                 : null,
-            onStructure: postStructure
+            onSlowStructure: postSlowStructure
                 ? async (structure) => {
                     await executeCallback({
-                        callbackType: 'structure',
+                        callbackType: 'slow-structure',
                         value: structure,
                     });
                 }
@@ -328,7 +328,7 @@ const startParsing = async (message, reader) => {
                     }
                     return async (sample) => {
                         await executeCallback({
-                            callbackType: 'on-audio-video-sample',
+                            callbackType: 'on-audio-sample',
                             value: sample,
                             trackId: params.track.trackId,
                         });
@@ -349,7 +349,7 @@ const startParsing = async (message, reader) => {
                     }
                     return async (sample) => {
                         await executeCallback({
-                            callbackType: 'on-audio-video-sample',
+                            callbackType: 'on-video-sample',
                             value: sample,
                             trackId: params.track.trackId,
                         });

package/dist/writers/writer.d.ts

@@ -1,4 +1,4 @@
-import type { LogLevel } from '../log';
+import type { MediaParserLogLevel } from '../log';
 export type Writer = {
     write: (arr: Uint8Array) => Promise<void>;
     finish: () => Promise<void>;
@@ -10,7 +10,7 @@ export type Writer = {
 export type CreateContent = (options: {
     filename: string;
     mimeType: string;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
 }) => Promise<Writer>;
 export type WriterInterface = {
     createContent: CreateContent;

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.298",
+  "version": "4.0.300",
   "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.298",
-    "@remotion/eslint-config-internal": "4.0.298"
+    "@remotion/eslint-config-internal": "4.0.300",
+    "@remotion/example-videos": "4.0.300"
   },
   "publishConfig": {
     "access": "public"