@remotion/media-parser 4.0.285 → 4.0.286

package/dist/containers/transport-stream/parse-packet.d.ts

@@ -1,5 +1,9 @@
-import type { ParserState } from '../../state/parser-state';
+import type { BufferIterator } from '../../iterator/buffer-iterator';
+import type { TransportStreamStructure } from '../../parse-result';
+import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
 import type { TransportStreamBox } from './boxes';
-export declare const parsePacket: ({ parserState, }: {
-    parserState: ParserState;
-}) => Promise<TransportStreamBox | null>;
+export declare const parsePacket: ({ iterator, structure, transportStream, }: {
+    iterator: BufferIterator;
+    structure: TransportStreamStructure;
+    transportStream: TransportStreamState;
+}) => TransportStreamBox | null;

package/dist/containers/transport-stream/parse-packet.js

@@ -6,8 +6,7 @@ const parse_pes_1 = require("./parse-pes");
 const parse_pmt_1 = require("./parse-pmt");
 const parse_stream_packet_1 = require("./parse-stream-packet");
 const traversal_1 = require("./traversal");
-const parsePacket = async ({ parserState, }) => {
-    const { iterator } = parserState;
+const parsePacket = ({ iterator, structure, transportStream, }) => {
     const offset = iterator.counter.getOffset();
     const syncByte = iterator.getUint8();
     if (syncByte !== 0x47) {
@@ -44,23 +43,23 @@ const parsePacket = async ({ parserState, }) => {
     }
     const read = iterator.counter.getOffset() - offset;
     if (read === 188) {
-        return Promise.resolve(null);
+        return null;
     }
-    const structure = parserState.structure.getTsStructure();
     const pat = structure.boxes.find((b) => b.type === 'transport-stream-pmt-box');
     const isPes = payloadUnitStartIndicator && (pat === null || pat === void 0 ? void 0 : pat.streams.find((e) => e.pid === programId));
     if (isPes) {
-        const packetPes = (0, parse_pes_1.parsePes)(iterator);
-        parserState.transportStream.nextPesHeaderStore.setNextPesHeader(packetPes);
+        const packetPes = (0, parse_pes_1.parsePes)({ iterator, offset });
+        transportStream.nextPesHeaderStore.setNextPesHeader(packetPes);
+        transportStream.observedPesHeaders.addPesHeader(packetPes);
     }
     else if (payloadUnitStartIndicator === 1) {
         iterator.getUint8(); // pointerField
     }
     if (programId === 0) {
-        return Promise.resolve((0, parse_pat_1.parsePat)(iterator));
+        return (0, parse_pat_1.parsePat)(iterator);
     }
     if (programId === 17) {
-        return Promise.resolve((0, parse_pat_1.parseSdt)(iterator));
+        return (0, parse_pat_1.parseSdt)(iterator);
     }
     // PID 17 is SDT
     // https://de.wikipedia.org/wiki/MPEG-Transportstrom
@@ -68,17 +67,17 @@ const parsePacket = async ({ parserState, }) => {
     const program = programId === 17 ? null : (0, traversal_1.getProgramForId)(structure, programId);
     if (program) {
         const pmt = (0, parse_pmt_1.parsePmt)(iterator);
-        return Promise.resolve(pmt);
+        return pmt;
     }
-    const stream = (0, traversal_1.getStreamForId)(structure, programId);
-    if (stream) {
-        await (0, parse_stream_packet_1.parseStream)({
-            transportStreamEntry: stream,
-            state: parserState,
+    const transportStreamEntry = (0, traversal_1.getStreamForId)(structure, programId);
+    if (transportStreamEntry) {
+        (0, parse_stream_packet_1.parseStream)({
+            transportStreamEntry,
+            iterator,
+            transportStream,
             programId,
-            structure,
         });
-        return Promise.resolve(null);
+        return null;
     }
     throw new Error('Unknown packet identifier');
 };

package/dist/containers/transport-stream/parse-pes.d.ts

@@ -4,5 +4,9 @@ export type PacketPes = {
     dts: number | null;
     pts: number;
     priority: number;
+    offset: number;
 };
-export declare const parsePes: (iterator: BufferIterator) => PacketPes;
+export declare const parsePes: ({ iterator, offset, }: {
+    iterator: BufferIterator;
+    offset: number;
+}) => PacketPes;

package/dist/containers/transport-stream/parse-pes.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parsePes = void 0;
-const parsePes = (iterator) => {
+const parsePes = ({ iterator, offset, }) => {
     const ident = iterator.getUint24();
     if (ident !== 0x000001) {
         throw new Error(`Unexpected PES packet start code: ${ident.toString(16)}`);
@@ -33,7 +33,7 @@ const parsePes = (iterator) => {
     iterator.getBits(1); // crc flag
     iterator.getBits(1); // extension flag
     const pesHeaderLength = iterator.getBits(8);
-    const offset = iterator.counter.getOffset();
+    const offsetAfterHeader = iterator.counter.getOffset();
     let pts = null;
     if (!ptsPresent) {
         throw new Error(`PTS is required`);
@@ -64,12 +64,13 @@ const parsePes = (iterator) => {
         dts = (dts1 << 30) | (dts2 << 15) | dts3;
     }
     iterator.stopReadingBits();
-    iterator.discard(pesHeaderLength - (iterator.counter.getOffset() - offset));
+    iterator.discard(pesHeaderLength - (iterator.counter.getOffset() - offsetAfterHeader));
     const packet = {
         dts,
         pts,
         streamId,
         priority,
+        offset,
     };
     return packet;
 };

package/dist/containers/transport-stream/parse-stream-packet.d.ts

@@ -1,9 +1,9 @@
-import type { TransportStreamStructure } from '../../parse-result';
-import type { ParserState } from '../../state/parser-state';
+import type { BufferIterator } from '../../iterator/buffer-iterator';
+import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
 import type { TransportStreamEntry } from './parse-pmt';
-export declare const parseStream: ({ transportStreamEntry, state, programId, structure, }: {
+export declare const parseStream: ({ transportStreamEntry, programId, iterator, transportStream, }: {
     transportStreamEntry: TransportStreamEntry;
-    state: ParserState;
     programId: number;
-    structure: TransportStreamStructure;
-}) => Promise<void>;
+    iterator: BufferIterator;
+    transportStream: TransportStreamState;
+}) => void;

package/dist/containers/transport-stream/parse-stream-packet.js

@@ -1,125 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseStream = void 0;
-const combine_uint8_arrays_1 = require("../../combine-uint8-arrays");
-const adts_header_1 = require("./adts-header");
 const discard_rest_of_packet_1 = require("./discard-rest-of-packet");
-const find_separator_1 = require("./find-separator");
 const process_stream_buffers_1 = require("./process-stream-buffers");
-const parseAdtsStream = async ({ transportStreamEntry, state, structure, offset, }) => {
-    var _a, _b;
-    const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
-    while (true) {
-        const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
-        if (!streamBuffer) {
-            throw new Error('Stream buffer not found');
-        }
-        const expectedLength = (_b = (_a = (0, adts_header_1.readAdtsHeader)(streamBuffer.buffer)) === null || _a === void 0 ? void 0 : _a.frameLength) !== null && _b !== void 0 ? _b : null;
-        if (expectedLength === null) {
-            break;
-        }
-        if (expectedLength > streamBuffer.buffer.length) {
-            break;
-        }
-        await (0, process_stream_buffers_1.processStreamBuffer)({
-            streamBuffer: {
-                buffer: streamBuffer.buffer.slice(0, expectedLength),
-                offset,
-                pesHeader: streamBuffer.pesHeader,
-            },
-            programId: transportStreamEntry.pid,
-            state,
-            structure,
-        });
-        const rest = streamBuffer.buffer.slice(expectedLength);
-        streamBuffers.set(transportStreamEntry.pid, {
-            buffer: rest,
-            pesHeader: nextPesHeader.getNextPesHeader(),
-            offset,
-        });
-    }
-};
-const parseAvcStream = async ({ programId, state, structure, streamBuffer, }) => {
-    const indexOfSeparator = (0, find_separator_1.findNthSubarrayIndex)(streamBuffer.buffer, new Uint8Array([0, 0, 1, 9]), 2);
-    if (indexOfSeparator === -1 || indexOfSeparator === 0) {
-        return null;
-    }
-    const packet = streamBuffer.buffer.slice(0, indexOfSeparator);
-    const rest = streamBuffer.buffer.slice(indexOfSeparator);
-    await (0, process_stream_buffers_1.processStreamBuffer)({
-        state,
-        streamBuffer: {
-            offset: streamBuffer.offset,
-            pesHeader: streamBuffer.pesHeader,
-            // Replace the regular 0x00000001 with 0x00000002 to avoid confusion with other 0x00000001 (?)
-            buffer: packet,
-        },
-        programId,
-        structure,
-    });
-    return rest;
-};
-const parseStream = async ({ transportStreamEntry, state, programId, structure, }) => {
-    const { iterator } = state;
-    let restOfPacket = (0, discard_rest_of_packet_1.getRestOfPacket)(iterator);
+const parseStream = ({ transportStreamEntry, programId, iterator, transportStream, }) => {
+    const restOfPacket = (0, discard_rest_of_packet_1.getRestOfPacket)(iterator);
     const offset = iterator.counter.getOffset();
-    if (transportStreamEntry.streamType === 27) {
-        const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
-        while (true) {
-            if (!streamBuffers.has(transportStreamEntry.pid)) {
-                streamBuffers.set(programId, {
-                    pesHeader: nextPesHeader.getNextPesHeader(),
-                    buffer: new Uint8Array([]),
-                    offset,
-                });
-            }
-            const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
-            streamBuffer.buffer = (0, combine_uint8_arrays_1.combineUint8Arrays)([
-                streamBuffer.buffer,
-                restOfPacket,
-            ]);
-            const rest = await parseAvcStream({
-                state,
-                programId,
-                structure,
-                streamBuffer: streamBuffers.get(transportStreamEntry.pid),
-            });
-            if (rest !== null) {
-                streamBuffers.delete(transportStreamEntry.pid);
-                if (rest.length === 0) {
-                    break;
-                }
-                restOfPacket = rest;
-            }
-            else {
-                break;
-            }
-        }
-        return;
-    }
-    if (transportStreamEntry.streamType === 15) {
-        const { streamBuffers, nextPesHeaderStore: nextPesHeader } = state.transportStream;
-        const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
-        if (!streamBuffer) {
-            streamBuffers.set(transportStreamEntry.pid, {
-                buffer: restOfPacket,
-                pesHeader: nextPesHeader.getNextPesHeader(),
-                offset,
-            });
-        }
-        else {
-            streamBuffer.buffer = (0, combine_uint8_arrays_1.combineUint8Arrays)([
-                streamBuffer.buffer,
-                restOfPacket,
-            ]);
-        }
-        return parseAdtsStream({
-            transportStreamEntry,
-            state,
-            structure,
+    const { streamBuffers, nextPesHeaderStore: nextPesHeader } = transportStream;
+    if (!streamBuffers.has(transportStreamEntry.pid)) {
+        streamBuffers.set(programId, (0, process_stream_buffers_1.makeTransportStreamPacketBuffer)({
+            pesHeader: nextPesHeader.getNextPesHeader(),
+            buffers: null,
             offset,
-        });
+        }));
     }
-    throw new Error(`Unsupported stream type ${transportStreamEntry.streamType}`);
+    const streamBuffer = streamBuffers.get(transportStreamEntry.pid);
+    streamBuffer.addBuffer(restOfPacket);
 };
 exports.parseStream = parseStream;

package/dist/containers/transport-stream/parse-transport-stream.js

@@ -2,23 +2,35 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTransportStream = void 0;
 const parse_packet_1 = require("./parse-packet");
+const process_sample_if_possible_1 = require("./process-sample-if-possible");
 const process_stream_buffers_1 = require("./process-stream-buffers");
 const parseTransportStream = async (state) => {
     const structure = state.structure.getTsStructure();
+    const processed = await (0, process_sample_if_possible_1.processSampleIfPossible)(state);
+    if (processed) {
+        return Promise.resolve(null);
+    }
     const { iterator } = state;
     if (iterator.bytesRemaining() < 188) {
         return Promise.resolve(null);
     }
-    const packet = await (0, parse_packet_1.parsePacket)({
-        parserState: state,
+    const packet = (0, parse_packet_1.parsePacket)({
+        iterator,
+        structure,
+        transportStream: state.transportStream,
     });
     if (packet) {
         structure.boxes.push(packet);
     }
     if (iterator.bytesRemaining() === 0) {
         await (0, process_stream_buffers_1.processFinalStreamBuffers)({
-            state,
+            transportStream: state.transportStream,
             structure,
+            sampleCallbacks: state.callbacks,
+            logLevel: state.logLevel,
+            onAudioTrack: state.onAudioTrack,
+            onVideoTrack: state.onVideoTrack,
+            makeSamplesStartAtZero: state.makeSamplesStartAtZero,
         });
     }
     return Promise.resolve(null);

package/dist/containers/transport-stream/process-stream-buffers.d.ts

@@ -1,19 +1,39 @@
+import type { LogLevel } from '../../log';
 import type { TransportStreamStructure } from '../../parse-result';
-import type { ParserState } from '../../state/parser-state';
+import type { SampleCallbacks } from '../../state/sample-callbacks';
+import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
+import type { OnAudioTrack, OnVideoTrack } from '../../webcodec-sample-types';
 import type { PacketPes } from './parse-pes';
 export type TransportStreamPacketBuffer = {
-    buffer: Uint8Array;
     pesHeader: PacketPes;
     offset: number;
+    getBuffer: () => Uint8Array;
+    addBuffer: (buffer: Uint8Array) => void;
+    get2ndSubArrayIndex: () => number;
 };
+export declare const makeTransportStreamPacketBuffer: ({ buffers, pesHeader, offset, }: {
+    buffers: Uint8Array | null;
+    pesHeader: PacketPes;
+    offset: number;
+}) => TransportStreamPacketBuffer;
 export type StreamBufferMap = Map<number, TransportStreamPacketBuffer>;
-export declare const processStreamBuffer: ({ streamBuffer, state, programId, structure, }: {
+export declare const processStreamBuffer: ({ streamBuffer, programId, structure, sampleCallbacks, logLevel, onAudioTrack, onVideoTrack, transportStream, makeSamplesStartAtZero, }: {
     streamBuffer: TransportStreamPacketBuffer;
-    state: ParserState;
     programId: number;
     structure: TransportStreamStructure;
+    sampleCallbacks: SampleCallbacks;
+    logLevel: LogLevel;
+    onAudioTrack: OnAudioTrack | null;
+    onVideoTrack: OnVideoTrack | null;
+    transportStream: TransportStreamState;
+    makeSamplesStartAtZero: boolean;
 }) => Promise<void>;
-export declare const processFinalStreamBuffers: ({ state, structure, }: {
-    state: ParserState;
+export declare const processFinalStreamBuffers: ({ structure, sampleCallbacks, logLevel, onAudioTrack, onVideoTrack, transportStream, makeSamplesStartAtZero, }: {
     structure: TransportStreamStructure;
+    sampleCallbacks: SampleCallbacks;
+    logLevel: LogLevel;
+    onAudioTrack: OnAudioTrack | null;
+    onVideoTrack: OnVideoTrack | null;
+    transportStream: TransportStreamState;
+    makeSamplesStartAtZero: boolean;
 }) => Promise<void>;

package/dist/containers/transport-stream/process-stream-buffers.js

@@ -1,52 +1,117 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processFinalStreamBuffers = exports.processStreamBuffer = void 0;
+exports.processFinalStreamBuffers = exports.processStreamBuffer = exports.makeTransportStreamPacketBuffer = void 0;
+const combine_uint8_arrays_1 = require("../../combine-uint8-arrays");
+const find_separator_1 = require("./find-separator");
 const get_tracks_1 = require("./get-tracks");
 const handle_aac_packet_1 = require("./handle-aac-packet");
 const handle_avc_packet_1 = require("./handle-avc-packet");
 const traversal_1 = require("./traversal");
-const processStreamBuffer = async ({ streamBuffer, state, programId, structure, }) => {
+const makeTransportStreamPacketBuffer = ({ buffers, pesHeader, offset, }) => {
+    let currentBuf = buffers ? [buffers] : [];
+    let subarrayIndex = null;
+    const getBuffer = () => {
+        if (currentBuf.length === 0) {
+            return new Uint8Array();
+        }
+        if (currentBuf.length === 1) {
+            return currentBuf[0];
+        }
+        currentBuf = [(0, combine_uint8_arrays_1.combineUint8Arrays)(currentBuf)];
+        return currentBuf[0];
+    };
+    let fastFind = null;
+    return {
+        pesHeader,
+        offset,
+        getBuffer,
+        addBuffer: (buffer) => {
+            currentBuf.push(buffer);
+            subarrayIndex = null;
+        },
+        get2ndSubArrayIndex: () => {
+            var _a, _b;
+            if (subarrayIndex === null) {
+                const result = (0, find_separator_1.findNthSubarrayIndex)({
+                    array: getBuffer(),
+                    subarray: new Uint8Array([0, 0, 1, 9]),
+                    n: 2,
+                    startIndex: (_a = fastFind === null || fastFind === void 0 ? void 0 : fastFind.index) !== null && _a !== void 0 ? _a : 0,
+                    startCount: (_b = fastFind === null || fastFind === void 0 ? void 0 : fastFind.count) !== null && _b !== void 0 ? _b : 0,
+                });
+                if (result.type === 'found') {
+                    subarrayIndex = result.index;
+                    fastFind = null;
+                }
+                else {
+                    fastFind = result;
+                    return -1;
+                }
+            }
+            return subarrayIndex;
+        },
+    };
+};
+exports.makeTransportStreamPacketBuffer = makeTransportStreamPacketBuffer;
+const processStreamBuffer = async ({ streamBuffer, programId, structure, sampleCallbacks, logLevel, onAudioTrack, onVideoTrack, transportStream, makeSamplesStartAtZero, }) => {
     const stream = (0, traversal_1.getStreamForId)(structure, programId);
     if (!stream) {
         throw new Error('No stream found');
     }
+    // 2 = ITU-T Rec. H.262 | ISO/IEC 13818-2 Video or ISO/IEC 11172-2 constrained parameter video stream
+    if (stream.streamType === 2) {
+        throw new Error('H.262 video stream not supported');
+    }
     // 27 = AVC / H.264 Video
     if (stream.streamType === 27) {
         await (0, handle_avc_packet_1.handleAvcPacket)({
             programId,
             streamBuffer,
-            state,
+            sampleCallbacks,
+            logLevel,
+            onVideoTrack,
             offset: streamBuffer.offset,
+            transportStream,
+            makeSamplesStartAtZero,
         });
     }
     // 15 = AAC / ADTS
     else if (stream.streamType === 15) {
         await (0, handle_aac_packet_1.handleAacPacket)({
             streamBuffer,
-            state,
             programId,
             offset: streamBuffer.offset,
+            sampleCallbacks,
+            logLevel,
+            onAudioTrack,
+            transportStream,
+            makeSamplesStartAtZero,
         });
     }
-    if (!state.callbacks.tracks.hasAllTracks()) {
-        const tracksRegistered = state.callbacks.tracks.getTracks().length;
+    if (!sampleCallbacks.tracks.hasAllTracks()) {
+        const tracksRegistered = sampleCallbacks.tracks.getTracks().length;
         const { streams } = (0, traversal_1.findProgramMapTableOrThrow)(structure);
         if ((0, get_tracks_1.filterStreamsBySupportedTypes)(streams).length === tracksRegistered) {
-            state.callbacks.tracks.setIsDone(state.logLevel);
+            sampleCallbacks.tracks.setIsDone(logLevel);
         }
     }
 };
 exports.processStreamBuffer = processStreamBuffer;
-const processFinalStreamBuffers = async ({ state, structure, }) => {
-    for (const [programId, buffer] of state.transportStream.streamBuffers) {
-        if (buffer.buffer.byteLength > 0) {
+const processFinalStreamBuffers = async ({ structure, sampleCallbacks, logLevel, onAudioTrack, onVideoTrack, transportStream, makeSamplesStartAtZero, }) => {
+    for (const [programId, buffer] of transportStream.streamBuffers) {
+        if (buffer.getBuffer().byteLength > 0) {
             await (0, exports.processStreamBuffer)({
                 streamBuffer: buffer,
-                state,
                 programId,
                 structure,
+                sampleCallbacks,
+                logLevel,
+                onAudioTrack,
+                onVideoTrack,
+                transportStream,
+                makeSamplesStartAtZero,
             });
-            state.transportStream.streamBuffers.delete(programId);
+            transportStream.streamBuffers.delete(programId);
         }
     }
 };

package/dist/containers/transport-stream/traversal.d.ts

@@ -1,6 +1,8 @@
 import type { TransportStreamStructure } from '../../parse-result';
+import type { TransportStreamPMTBox } from './boxes';
 import type { TransportStreamProgramAssociationTableEntry } from './parse-pat';
 import type { TransportStreamEntry } from './parse-pmt';
-export declare const findProgramMapTableOrThrow: (structure: TransportStreamStructure) => import("./boxes").TransportStreamPMTBox;
+export declare const findProgramMapOrNull: (structure: TransportStreamStructure) => TransportStreamPMTBox | null;
+export declare const findProgramMapTableOrThrow: (structure: TransportStreamStructure) => TransportStreamPMTBox;
 export declare const getProgramForId: (structure: TransportStreamStructure, packetIdentifier: number) => TransportStreamProgramAssociationTableEntry | null;
 export declare const getStreamForId: (structure: TransportStreamStructure, packetIdentifier: number) => TransportStreamEntry | null;

package/dist/containers/transport-stream/traversal.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getStreamForId = exports.getProgramForId = exports.findProgramMapTableOrThrow = void 0;
+exports.getStreamForId = exports.getProgramForId = exports.findProgramMapTableOrThrow = exports.findProgramMapOrNull = void 0;
 const findProgramAssociationTableOrThrow = (structure) => {
     const box = structure.boxes.find((b) => b.type === 'transport-stream-pat-box');
     if (!box) {
@@ -8,8 +8,16 @@ const findProgramAssociationTableOrThrow = (structure) => {
     }
     return box;
 };
-const findProgramMapTableOrThrow = (structure) => {
+const findProgramMapOrNull = (structure) => {
     const box = structure.boxes.find((b) => b.type === 'transport-stream-pmt-box');
+    if (!box) {
+        return null;
+    }
+    return box;
+};
+exports.findProgramMapOrNull = findProgramMapOrNull;
+const findProgramMapTableOrThrow = (structure) => {
+    const box = (0, exports.findProgramMapOrNull)(structure);
     if (!box) {
         throw new Error('No PMT box found');
     }

package/dist/containers/wav/parse-fmt.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseFmt = void 0;
 const register_track_1 = require("../../register-track");
-const work_on_seek_request_1 = require("../../work-on-seek-request");
 const parseFmt = async ({ state, }) => {
     const { iterator } = state;
     const ckSize = iterator.getUint32Le(); // chunkSize
@@ -36,7 +35,6 @@ const parseFmt = async ({ state, }) => {
     };
     state.structure.getWavStructure().boxes.push(wavHeader);
     await (0, register_track_1.registerAudioTrack)({
-        workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
         track: {
             type: 'audio',
             codec: format,

package/dist/containers/wav/parse-media-section.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMediaSection = void 0;
 const convert_audio_or_video_sample_1 = require("../../convert-audio-or-video-sample");
 const emit_audio_sample_1 = require("../../emit-audio-sample");
-const work_on_seek_request_1 = require("../../work-on-seek-request");
 const get_seeking_byte_1 = require("./get-seeking-byte");
 const parseMediaSection = async ({ state, }) => {
     const { iterator } = state;
@@ -36,7 +35,6 @@ const parseMediaSection = async ({ state, }) => {
             },
             timescale: 1,
         }),
-        workOnSeekRequestOptions: (0, work_on_seek_request_1.getWorkOnSeekRequestOptions)(state),
         callbacks: state.callbacks,
     });
     return null;

package/dist/containers/webm/cues/fetch-web-cues.d.ts

@@ -0,0 +1,12 @@
+import type { MediaParserController } from '../../../controller/media-parser-controller';
+import type { LogLevel } from '../../../log';
+import type { ParseMediaSrc } from '../../../options';
+import type { ReaderInterface } from '../../../readers/reader';
+import type { MatroskaCue } from './format-cues';
+export declare const fetchWebmCues: ({ src, readerInterface, controller, position, logLevel, }: {
+    src: ParseMediaSrc;
+    readerInterface: ReaderInterface;
+    controller: MediaParserController;
+    position: number;
+    logLevel: LogLevel;
+}) => Promise<MatroskaCue[] | null>;

package/dist/containers/webm/cues/fetch-web-cues.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchWebmCues = void 0;
+const buffer_iterator_1 = require("../../../iterator/buffer-iterator");
+const segments_1 = require("../segments");
+const format_cues_1 = require("./format-cues");
+const fetchWebmCues = async ({ src, readerInterface, controller, position, logLevel, }) => {
+    const result = await readerInterface.read({
+        controller,
+        range: position,
+        src,
+    });
+    const { value } = await result.reader.reader.read();
+    if (!value) {
+        return null;
+    }
+    result.reader.abort();
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(value, value.length);
+    const segment = await (0, segments_1.expectSegment)({
+        iterator,
+        logLevel,
+        statesForProcessing: null,
+        isInsideSegment: null,
+        mediaSectionState: null,
+    });
+    iterator.destroy();
+    if (!(segment === null || segment === void 0 ? void 0 : segment.value)) {
+        return null;
+    }
+    return (0, format_cues_1.formatCues)(segment.value);
+};
+exports.fetchWebmCues = fetchWebmCues;

package/dist/containers/webm/cues/format-cues.d.ts

@@ -0,0 +1,8 @@
+import type { PossibleEbml } from '../segments/all-segments';
+export type MatroskaCue = {
+    trackId: number;
+    timeInTimescale: number;
+    clusterPositionInSegment: number;
+    relativePosition: number;
+};
+export declare const formatCues: (cues: PossibleEbml[]) => MatroskaCue[];