@remotion/media-parser 4.0.278 → 4.0.280

package/dist/perform-seek.js

@@ -2,36 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.performSeek = void 0;
 const log_1 = require("./log");
-const performSeek = async ({ seekTo, state, currentReader, readerInterface, src, }) => {
-    const { iterator, logLevel, controller, mode, contentLength } = state;
-    if (seekTo <= iterator.counter.getOffset()) {
-        throw new Error(`Seeking backwards is not supported. Current position: ${iterator.counter.getOffset()}, seekTo: ${seekTo}`);
+const seek_backwards_1 = require("./seek-backwards");
+const seek_forwards_1 = require("./seek-forwards");
+const performSeek = async ({ seekTo, state, }) => {
+    var _a, _b;
+    const { iterator, logLevel, mode, contentLength } = state;
+    if (seekTo <= iterator.counter.getOffset() && mode === 'download') {
+        throw new Error(`Seeking backwards is not supported in parseAndDownloadMedia() mode. Current position: ${iterator.counter.getOffset()}, seekTo: ${seekTo}`);
     }
     if (seekTo > state.contentLength) {
-        throw new Error(`Unexpected seek: ${seekTo} > ${contentLength}`);
-    }
-    if (iterator.counter.getOffset() + iterator.bytesRemaining() >= seekTo) {
-        log_1.Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Data already fetched`);
-        iterator.discard(seekTo - iterator.counter.getOffset());
-        return currentReader;
+        throw new Error(`Cannot seek beyond the end of the file: ${seekTo} > ${contentLength}`);
     }
     if (mode === 'download') {
         log_1.Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Fetching but not reading all the data inbetween because in download mode`);
         iterator.discard(seekTo - iterator.counter.getOffset());
-        return currentReader;
+        return;
+    }
+    await ((_a = state.controller) === null || _a === void 0 ? void 0 : _a._internals.checkForAbortAndPause());
+    const alreadyAtByte = iterator.counter.getOffset() === seekTo;
+    if (alreadyAtByte) {
+        log_1.Log.verbose(logLevel, `Already at the desired position, seeking done`);
+        return;
+    }
+    const skippingForward = seekTo > iterator.counter.getOffset();
+    if (skippingForward) {
+        await (0, seek_forwards_1.seekForward)(state, seekTo);
+    }
+    else {
+        await (0, seek_backwards_1.seekBackwards)(state, seekTo);
     }
-    const time = Date.now();
-    log_1.Log.verbose(logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Re-reading because this portion is not available`);
-    currentReader.abort();
-    await (controller === null || controller === void 0 ? void 0 : controller._internals.checkForAbortAndPause());
-    const { reader: newReader } = await readerInterface.read({
-        src,
-        range: seekTo,
-        controller,
-    });
-    iterator.skipTo(seekTo);
-    await state.discardReadBytes(true);
-    log_1.Log.verbose(logLevel, `Re-reading took ${Date.now() - time}ms. New position: ${iterator.counter.getOffset()}`);
-    return newReader;
+    await ((_b = state.controller) === null || _b === void 0 ? void 0 : _b._internals.checkForAbortAndPause());
 };
 exports.performSeek = performSeek;

package/dist/print-timings.d.ts

@@ -0,0 +1,2 @@
+import type { ParserState } from './state/parser-state';
+export declare const printTimings: (state: ParserState) => void;

package/dist/print-timings.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printTimings = void 0;
+const log_1 = require("./log");
+const printTimings = (state) => {
+    log_1.Log.verbose(state.logLevel, `Time iterating over file: ${state.timings.timeIterating}ms`);
+    log_1.Log.verbose(state.logLevel, `Time fetching data: ${state.timings.timeReadingData}ms`);
+    log_1.Log.verbose(state.logLevel, `Time seeking: ${state.timings.timeSeeking}ms`);
+    log_1.Log.verbose(state.logLevel, `Time checking if done: ${state.timings.timeCheckingIfDone}ms`);
+    log_1.Log.verbose(state.logLevel, `Time freeing data: ${state.timings.timeFreeingData}ms`);
+};
+exports.printTimings = printTimings;

package/dist/register-track.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerVideoTrackWhenProfileIsAvailable = exports.registerAudioTrack = exports.registerVideoTrack = void 0;
 const add_avc_profile_to_track_1 = require("./add-avc-profile-to-track");
 const log_1 = require("./log");
+const work_on_seek_request_1 = require("./work-on-seek-request");
 const registerVideoTrack = async ({ state, track, container, }) => {
     if (state.callbacks.tracks.getTracks().find((t) => t.trackId === track.trackId)) {
         log_1.Log.trace(state.logLevel, `Track ${track.trackId} already registered, skipping`);
@@ -17,6 +18,7 @@ const registerVideoTrack = async ({ state, track, container, }) => {
     }
     const callback = await state.onVideoTrack({ track, container });
     await state.callbacks.registerVideoSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+    await (0, work_on_seek_request_1.workOnSeekRequest)(state);
     return callback;
 };
 exports.registerVideoTrack = registerVideoTrack;
@@ -34,6 +36,7 @@ const registerAudioTrack = async ({ state, track, container, }) => {
     }
     const callback = await state.onAudioTrack({ track, container });
     await state.callbacks.registerAudioSampleCallback(track.trackId, callback !== null && callback !== void 0 ? callback : null);
+    await (0, work_on_seek_request_1.workOnSeekRequest)(state);
     return callback;
 };
 exports.registerAudioTrack = registerAudioTrack;

package/dist/run-parse-iteration.d.ts

@@ -1,8 +1,5 @@
 import type { ParseResult } from './parse-result';
 import type { ParserState } from './state/parser-state';
-export declare const runParseIteration: ({ state, mimeType, contentLength, name, }: {
+export declare const runParseIteration: ({ state, }: {
     state: ParserState;
-    mimeType: string | null;
-    contentLength: number;
-    name: string | null;
 }) => Promise<ParseResult>;

package/dist/run-parse-iteration.js

@@ -11,7 +11,7 @@ const parse_transport_stream_1 = require("./containers/transport-stream/parse-tr
 const parse_wav_1 = require("./containers/wav/parse-wav");
 const parse_webm_header_1 = require("./containers/webm/parse-webm-header");
 const init_video_1 = require("./init-video");
-const runParseIteration = async ({ state, mimeType, contentLength, name, }) => {
+const runParseIteration = async ({ state, }) => {
     const structure = state.getStructureOrNull();
     // m3u8 is busy parsing the chunks once the manifest has been read
     if (structure && structure.type === 'm3u') {
@@ -23,9 +23,6 @@ const runParseIteration = async ({ state, mimeType, contentLength, name, }) => {
     if (structure === null) {
         await (0, init_video_1.initVideo)({
             state,
-            mimeType,
-            name,
-            contentLength,
         });
         return null;
     }

package/dist/seek-backwards.d.ts

@@ -0,0 +1,2 @@
+import type { ParserState } from './state/parser-state';
+export declare const seekBackwards: (state: ParserState, seekTo: number) => Promise<void>;

package/dist/seek-backwards.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seekBackwards = void 0;
+const log_1 = require("./log");
+const seekBackwards = async (state, seekTo) => {
+    const { iterator } = state;
+    // (a) data has not been discarded yet
+    const howManyBytesNotYetDiscarded = iterator.counter.getDiscardedOffset();
+    const howManyBytesWeCanGoBack = iterator.counter.getOffset() - howManyBytesNotYetDiscarded;
+    if (iterator.counter.getOffset() - howManyBytesWeCanGoBack <= seekTo) {
+        iterator.skipTo(seekTo);
+        return;
+    }
+    // (b) data has been discarded, making new reader
+    const time = Date.now();
+    log_1.Log.verbose(state.logLevel, `Seeking in video from position ${iterator.counter.getOffset()} -> ${seekTo}. Re-reading because this portion is not available`);
+    const { reader: newReader } = await state.readerInterface.read({
+        src: state.src,
+        range: seekTo,
+        controller: state.controller,
+    });
+    iterator.replaceData(new Uint8Array([]), seekTo);
+    log_1.Log.verbose(state.logLevel, `Re-reading took ${Date.now() - time}ms. New position: ${iterator.counter.getOffset()}`);
+    state.currentReader = newReader;
+};
+exports.seekBackwards = seekBackwards;

package/dist/seek-forwards.d.ts

@@ -0,0 +1,2 @@
+import type { ParserState } from './state/parser-state';
+export declare const seekForward: (state: ParserState, seekTo: number) => Promise<import("./readers/reader").Reader | undefined>;

package/dist/seek-forwards.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seekForward = void 0;
+const log_1 = require("./log");
+const seekForward = async (state, seekTo) => {
+    const { iterator } = state;
+    const alreadyHasBuffer = iterator.bytesRemaining() >= seekTo - iterator.counter.getOffset();
+    log_1.Log.verbose(state.logLevel, `Performing seek from ${iterator.counter.getOffset()} to ${seekTo}`);
+    // (a) starting byte has already been fetched
+    if (alreadyHasBuffer) {
+        iterator.skipTo(seekTo);
+        log_1.Log.verbose(state.logLevel, `Already read ahead enough, skipping forward`);
+        return state.currentReader;
+    }
+    // (b) starting byte has not been fetched yet, making new reader
+    const time = Date.now();
+    log_1.Log.verbose(state.logLevel, `Skipping over video data from position ${iterator.counter.getOffset()} -> ${seekTo}. Re-reading because this portion is not available`);
+    const { reader: newReader } = await state.readerInterface.read({
+        src: state.src,
+        range: seekTo,
+        controller: state.controller,
+    });
+    iterator.skipTo(seekTo);
+    await state.discardReadBytes(true);
+    log_1.Log.verbose(state.logLevel, `Re-reading took ${Date.now() - time}ms. New position: ${iterator.counter.getOffset()}`);
+    state.currentReader = newReader;
+};
+exports.seekForward = seekForward;

package/dist/seek-signal.d.ts

@@ -0,0 +1,22 @@
+export type SeekSignal = {
+    seek: (seek: Seek) => void;
+    getSeek: () => Seek | undefined;
+    clearSeekIfStillSame: (previousSeek: Seek) => {
+        hasChanged: boolean;
+    };
+};
+type SeekToTime = {
+    type: 'keyframe-before-time-in-seconds';
+    time: number;
+};
+type SeekToByte = {
+    type: 'byte';
+    byte: number;
+};
+type ForceSeekToByte = {
+    type: 'force-seek-to-byte';
+    byte: number;
+};
+export type Seek = SeekToTime | SeekToByte | ForceSeekToByte;
+export declare const makeSeekSignal: () => SeekSignal;
+export {};

package/dist/seek-signal.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSeekSignal = void 0;
+const makeSeekSignal = () => {
+    let seek;
+    return {
+        seek: (time) => {
+            if (seek) {
+                throw new Error('Seek already requested, must wait');
+            }
+            seek = time;
+        },
+        getSeek() {
+            return seek;
+        },
+        // In the meanwhile a new seek could have been queued
+        clearSeekIfStillSame(previousSeek) {
+            if (seek === previousSeek) {
+                seek = undefined;
+                return { hasChanged: false };
+            }
+            return { hasChanged: true };
+        },
+    };
+};
+exports.makeSeekSignal = makeSeekSignal;

package/dist/seeking-info.d.ts

@@ -0,0 +1,8 @@
+import type { IsoBaseMediaBox } from './containers/iso-base-media/base-media-box';
+import type { MoovBox } from './containers/iso-base-media/moov/moov';
+export type IsoBaseMediaSeekingInfo = {
+    type: 'iso-base-media-seeking-info';
+    moovBox: MoovBox;
+    moofBoxes: IsoBaseMediaBox[];
+};
+export type SeekingInfo = IsoBaseMediaSeekingInfo;

package/dist/seeking-info.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/state/can-skip-tracks.d.ts

@@ -1,9 +1,9 @@
-import type { Options, ParseMediaFields } from '../options';
+import type { Options, ParseMediaFields } from '../fields';
 import type { MediaParserStructureUnstable } from '../parse-result';
 import type { StructureState } from './structure';
 export declare const needsTracksForField: ({ field, structure, }: {
     field: keyof Options<ParseMediaFields>;
-    structure: MediaParserStructureUnstable;
+    structure: MediaParserStructureUnstable | null;
 }) => boolean;
 export declare const makeCanSkipTracksState: ({ hasAudioTrackHandlers, fields, hasVideoTrackHandlers, structure, }: {
     hasAudioTrackHandlers: boolean;

package/dist/state/can-skip-tracks.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeCanSkipTracksState = exports.needsTracksForField = void 0;
 const needsTracksForField = ({ field, structure, }) => {
     if (field === 'dimensions') {
-        if (structure.type === 'riff') {
+        if ((structure === null || structure === void 0 ? void 0 : structure.type) === 'riff') {
             return false;
         }
         return true;
@@ -50,7 +50,10 @@ const makeCanSkipTracksState = ({ hasAudioTrackHandlers, fields, hasVideoTrackHa
             }
             const keys = Object.keys(fields !== null && fields !== void 0 ? fields : {});
             const selectedKeys = keys.filter((k) => fields[k]);
-            return !selectedKeys.some((k) => (0, exports.needsTracksForField)({ field: k, structure: structure.getStructure() }));
+            return !selectedKeys.some((k) => (0, exports.needsTracksForField)({
+                field: k,
+                structure: structure.getStructureOrNull(),
+            }));
         },
     };
 };

package/dist/state/emitted-fields.d.ts

@@ -1,2 +1,2 @@
-import type { AllOptions, ParseMediaFields } from '../options';
+import type { AllOptions, ParseMediaFields } from '../fields';
 export declare const emittedState: () => AllOptions<ParseMediaFields>;

package/dist/state/has-tracks-section.d.ts

@@ -1,6 +1,7 @@
+import type { Options, ParseMediaFields } from '../fields';
 import type { Track } from '../get-tracks';
 import type { LogLevel } from '../log';
-import type { Options, ParseMediaFields, ParseMediaSrc } from '../options';
+import type { ParseMediaSrc } from '../options';
 import type { CanSkipTracksState } from './can-skip-tracks';
 export declare const makeTracksSectionState: (canSkipTracksState: CanSkipTracksState, src: ParseMediaSrc) => {
     hasAllTracks: () => boolean;

package/dist/state/need-samples-for-fields.d.ts

@@ -1,4 +1,4 @@
-import type { AllOptions, Options, ParseMediaFields } from '../options';
+import type { AllOptions, Options, ParseMediaFields } from '../fields';
 export declare const needsToIterateOverSamples: ({ fields, emittedFields, }: {
     fields: Options<ParseMediaFields>;
     emittedFields: AllOptions<ParseMediaFields>;

package/dist/state/parser-state.d.ts

@@ -1,11 +1,12 @@
-import { type BufferIterator } from '../buffer-iterator';
 import type { AvcPPs, AvcProfileInfo } from '../containers/avc/parse-avc';
 import type { SelectM3uAssociatedPlaylistsFn, SelectM3uStreamFn } from '../containers/m3u/select-stream';
+import type { Options, ParseMediaFields } from '../fields';
+import { type BufferIterator } from '../iterator/buffer-iterator';
 import { type LogLevel } from '../log';
 import type { MediaParserController } from '../media-parser-controller';
-import type { OnDiscardedData, Options, ParseMediaFields, ParseMediaMode, ParseMediaSrc } from '../options';
+import type { AllParseMediaFields, OnDiscardedData, ParseMediaCallbacks, ParseMediaMode, ParseMediaResult, ParseMediaSrc } from '../options';
 import type { IsoBaseMediaStructure } from '../parse-result';
-import type { ReaderInterface } from '../readers/reader';
+import type { Reader, ReaderInterface } from '../readers/reader';
 import type { OnAudioTrack, OnVideoTrack } from '../webcodec-sample-types';
 export type InternalStats = {
     skippedBytes: number;
@@ -15,11 +16,10 @@ export type SpsAndPps = {
     sps: AvcProfileInfo;
     pps: AvcPPs;
 };
-export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, fields, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, mp4HeaderSegment, }: {
+export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, mp4HeaderSegment, contentType, name, callbacks, fieldsInReturnValue, mimeType, initialReaderInstance, }: {
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
     controller: MediaParserController;
-    fields: Options<ParseMediaFields>;
     onAudioTrack: OnAudioTrack | null;
     onVideoTrack: OnVideoTrack | null;
     contentLength: number;
@@ -31,11 +31,17 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     selectM3uStreamFn: SelectM3uStreamFn;
     selectM3uAssociatedPlaylistsFn: SelectM3uAssociatedPlaylistsFn;
     mp4HeaderSegment: IsoBaseMediaStructure | null;
+    contentType: string | null;
+    name: string;
+    callbacks: ParseMediaCallbacks;
+    fieldsInReturnValue: Options<ParseMediaFields>;
+    mimeType: string | null;
+    initialReaderInstance: Reader;
 }) => {
     onAudioTrack: OnAudioTrack | null;
     onVideoTrack: OnVideoTrack | null;
-    emittedFields: import("../options").AllOptions<ParseMediaFields>;
-    fields: Partial<import("../options").AllOptions<ParseMediaFields>>;
+    emittedFields: import("../fields").AllOptions<ParseMediaFields>;
+    fields: Partial<import("../fields").AllOptions<ParseMediaFields>>;
     slowDurationAndFps: {
         addVideoSample: (videoSample: import("../webcodec-sample-types").AudioOrVideoSample) => void;
         addAudioSample: (audioSample: import("../webcodec-sample-types").AudioOrVideoSample) => void;
@@ -67,7 +73,15 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         stopReadingBits: () => void;
         skipTo: (offset: number) => void;
         addData: (newData: Uint8Array) => void;
-        counter: import("../buffer-iterator").OffsetCounter;
+        counter: {
+            getOffset: () => number;
+            discardBytes: (bytes: number) => void;
+            increment: (bytes: number) => void;
+            getDiscardedBytes: () => number;
+            setDiscardedOffset: (bytes: number) => void;
+            getDiscardedOffset: () => number;
+            decrement: (bytes: number) => void;
+        };
         peekB: (length: number) => void;
         peekD: (length: number) => void;
         getBits: (bits: number) => number;
@@ -124,6 +138,7 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         getFlacCodecNumber: () => number;
         readUntilLineEnd: () => string | null;
         getSyncSafeInt32: () => number;
+        replaceData: (newData: Uint8Array, seekTo: number) => void;
     };
     controller: MediaParserController;
     mode: ParseMediaMode;
@@ -133,6 +148,14 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
     selectM3uStreamFn: SelectM3uStreamFn;
     selectM3uAssociatedPlaylistsFn: SelectM3uAssociatedPlaylistsFn;
     mp4HeaderSegment: IsoBaseMediaStructure | null;
+    contentType: string | null;
+    name: string;
+    returnValue: ParseMediaResult<AllParseMediaFields>;
+    callbackFunctions: Partial<import("../options").ParseMediaCallbacksMandatory>;
+    fieldsInReturnValue: Partial<import("../fields").AllOptions<ParseMediaFields>>;
+    mimeType: string | null;
+    errored: Error | null;
+    currentReader: Reader;
     getStructureOrNull: () => import("../parse-result").MediaParserStructureUnstable | null;
     getStructure: () => import("../parse-result").MediaParserStructureUnstable;
     setStructure: (value: import("../parse-result").MediaParserStructureUnstable) => void;
@@ -245,6 +268,13 @@ export declare const makeParserState: ({ hasAudioTrackHandlers, hasVideoTrackHan
         setMp4HeaderSegment: (playlistUrl: string, structure: IsoBaseMediaStructure) => void;
         getMp4HeaderSegment: (playlistUrl: string) => IsoBaseMediaStructure;
     };
+    timings: {
+        timeIterating: number;
+        timeReadingData: number;
+        timeSeeking: number;
+        timeCheckingIfDone: number;
+        timeFreeingData: number;
+    };
     callbacks: {
         registerVideoSampleCallback: (id: number, callback: import("../webcodec-sample-types").OnVideoSample | null) => Promise<void>;
         onAudioSample: (trackId: number, audioSample: import("../webcodec-sample-types").AudioOrVideoSample) => Promise<void>;

package/dist/state/parser-state.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeParserState = void 0;
-const buffer_iterator_1 = require("../buffer-iterator");
+const get_fields_from_callbacks_1 = require("../get-fields-from-callbacks");
+const buffer_iterator_1 = require("../iterator/buffer-iterator");
 const log_1 = require("../log");
 const aac_state_1 = require("./aac-state");
 const emitted_fields_1 = require("./emitted-fields");
@@ -15,11 +16,13 @@ const riff_1 = require("./riff");
 const sample_callbacks_1 = require("./sample-callbacks");
 const slow_duration_fps_1 = require("./slow-duration-fps");
 const structure_1 = require("./structure");
+const timings_1 = require("./timings");
 const transport_stream_1 = require("./transport-stream");
 const video_section_1 = require("./video-section");
 const webm_1 = require("./webm");
-const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, fields, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, mp4HeaderSegment, }) => {
+const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, controller, onAudioTrack, onVideoTrack, contentLength, logLevel, mode, src, readerInterface, onDiscardedData, selectM3uStreamFn, selectM3uAssociatedPlaylistsFn, mp4HeaderSegment, contentType, name, callbacks, fieldsInReturnValue, mimeType, initialReaderInstance, }) => {
     let skippedBytes = 0;
+    const returnValue = {};
     const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(new Uint8Array([]), contentLength);
     const increaseSkippedBytes = (bytes) => {
         skippedBytes += bytes;
@@ -30,6 +33,8 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
     const slowDurationAndFps = (0, slow_duration_fps_1.slowDurationAndFpsState)();
     const mp3Info = (0, mp3_1.makeMp3State)();
     const images = (0, images_1.imagesState)();
+    const timings = (0, timings_1.timingsState)();
+    const errored = null;
     const discardReadBytes = async (force) => {
         const { bytesRemoved, removedData } = iterator.removeBytesRead(force, mode);
         if (bytesRemoved) {
@@ -39,6 +44,10 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
             await onDiscardedData(removedData);
         }
     };
+    const fields = (0, get_fields_from_callbacks_1.getFieldsFromCallback)({
+        fields: fieldsInReturnValue,
+        callbacks,
+    });
     return {
         riff: (0, riff_1.riffSpecificState)(),
         transportStream: (0, transport_stream_1.transportStreamState)(),
@@ -48,6 +57,7 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
         aac: (0, aac_state_1.aacState)(),
         flac: (0, flac_state_1.flacState)(),
         m3u: (0, m3u_state_1.m3uState)(logLevel),
+        timings,
         callbacks: (0, sample_callbacks_1.sampleCallback)({
             controller,
             hasAudioTrackHandlers,
@@ -58,6 +68,8 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
             slowDurationAndFpsState: slowDurationAndFps,
             structure,
             src,
+            seekSignal: controller._internals.seekSignal,
+            logLevel,
         }),
         getInternalStats: () => {
             var _a;
@@ -88,6 +100,14 @@ const makeParserState = ({ hasAudioTrackHandlers, hasVideoTrackHandlers, control
         selectM3uStreamFn,
         selectM3uAssociatedPlaylistsFn,
         mp4HeaderSegment,
+        contentType,
+        name,
+        returnValue,
+        callbackFunctions: callbacks,
+        fieldsInReturnValue,
+        mimeType,
+        errored: errored,
+        currentReader: initialReaderInstance,
     };
 };
 exports.makeParserState = makeParserState;

package/dist/state/sample-callbacks.d.ts

@@ -1,10 +1,13 @@
+import type { AllOptions, Options, ParseMediaFields } from '../fields';
+import type { LogLevel } from '../log';
 import type { MediaParserController } from '../media-parser-controller';
-import type { AllOptions, Options, ParseMediaFields, ParseMediaSrc } from '../options';
+import type { ParseMediaSrc } from '../options';
+import type { SeekSignal } from '../seek-signal';
 import type { AudioOrVideoSample, OnAudioSample, OnVideoSample } from '../webcodec-sample-types';
 import { type KeyframesState } from './keyframes';
 import type { SlowDurationAndFpsState } from './slow-duration-fps';
 import type { StructureState } from './structure';
-export declare const sampleCallback: ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, src, }: {
+export declare const sampleCallback: ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, src, seekSignal, logLevel, }: {
     controller: MediaParserController;
     hasAudioTrackHandlers: boolean;
     hasVideoTrackHandlers: boolean;
@@ -14,6 +17,8 @@ export declare const sampleCallback: ({ controller, hasAudioTrackHandlers, hasVi
     slowDurationAndFpsState: SlowDurationAndFpsState;
     structure: StructureState;
     src: ParseMediaSrc;
+    seekSignal: SeekSignal;
+    logLevel: LogLevel;
 }) => {
     registerVideoSampleCallback: (id: number, callback: OnVideoSample | null) => Promise<void>;
     onAudioSample: (trackId: number, audioSample: AudioOrVideoSample) => Promise<void>;
@@ -26,7 +31,7 @@ export declare const sampleCallback: ({ controller, hasAudioTrackHandlers, hasVi
     tracks: {
         hasAllTracks: () => boolean;
         getIsDone: () => boolean;
-        setIsDone: (logLevel: import("..").LogLevel) => void;
+        setIsDone: (logLevel: LogLevel) => void;
         addTrack: (track: import("..").Track) => void;
         getTracks: () => import("..").Track[];
         ensureHasTracksAtEnd: (fields: Options<ParseMediaFields>) => void;

package/dist/state/sample-callbacks.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sampleCallback = void 0;
+const log_1 = require("../log");
 const can_skip_tracks_1 = require("./can-skip-tracks");
 const has_tracks_section_1 = require("./has-tracks-section");
 const need_samples_for_fields_1 = require("./need-samples-for-fields");
-const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, src, }) => {
+const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, structure, src, seekSignal, logLevel, }) => {
     const videoSampleCallbacks = {};
     const audioSampleCallbacks = {};
     const queuedAudioSamples = {};
@@ -42,7 +43,13 @@ const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandle
                 samplesForTrack[trackId]++;
                 // If we emit samples with data length 0, Chrome will fail
                 if (callback) {
-                    await callback(audioSample);
+                    if (seekSignal.getSeek()) {
+                        log_1.Log.verbose(logLevel, 'Not emitting sample because seek is processing');
+                    }
+                    else {
+                        await callback(audioSample);
+                        // TODO: work on seek request
+                    }
                 }
             }
             if ((0, need_samples_for_fields_1.needsToIterateOverSamples)({ emittedFields, fields })) {
@@ -65,7 +72,13 @@ const sampleCallback = ({ controller, hasAudioTrackHandlers, hasVideoTrackHandle
                 const callback = videoSampleCallbacks[trackId];
                 // If we emit samples with data 0, Chrome will fail
                 if (callback) {
-                    await callback(videoSample);
+                    if (seekSignal.getSeek()) {
+                        log_1.Log.verbose(logLevel, 'Not emitting sample because seek is processing');
+                    }
+                    else {
+                        await callback(videoSample);
+                        // TODO: work on seek request
+                    }
                 }
             }
             if ((0, need_samples_for_fields_1.needsToIterateOverSamples)({