@remotion/media-parser 4.0.289 → 4.0.291

package/dist/containers/iso-base-media/turn-sample-positions-into-array.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.turnGroupIntoOld = exports.turnIntoOld = exports.turnSamplePositionsIntoArraySlow = void 0;
+const turnSamplePositionsIntoArraySlow = ({ stcoBox, stszBox, stscBox, stssBox, sttsBox, cttsBox, onlyKeyframes, }) => {
+    var _a;
+    const sttsDeltas = [];
+    for (const distribution of sttsBox.sampleDistribution) {
+        for (let i = 0; i < distribution.sampleCount; i++) {
+            sttsDeltas.push(distribution.sampleDelta);
+        }
+    }
+    const cttsEntries = [];
+    for (const entry of (_a = cttsBox === null || cttsBox === void 0 ? void 0 : cttsBox.entries) !== null && _a !== void 0 ? _a : [
+        { sampleCount: sttsDeltas.length, sampleOffset: 0 },
+    ]) {
+        for (let i = 0; i < entry.sampleCount; i++) {
+            cttsEntries.push(entry.sampleOffset);
+        }
+    }
+    let dts = 0;
+    const samples = [];
+    let samplesPerChunk = 1;
+    for (let i = 0; i < stcoBox.entries.length; i++) {
+        const hasEntry = stscBox.entries.find((entry) => entry.firstChunk === i + 1);
+        if (hasEntry) {
+            samplesPerChunk = hasEntry.samplesPerChunk;
+        }
+        let offsetInThisChunk = 0;
+        for (let j = 0; j < samplesPerChunk; j++) {
+            const isKeyframe = stssBox
+                ? stssBox.sampleNumber.includes(samples.length + 1)
+                : true;
+            if (onlyKeyframes && !isKeyframe) {
+                continue;
+            }
+            const size = stszBox.countType === 'fixed'
+                ? stszBox.sampleSize
+                : stszBox.entries[samples.length];
+            const delta = sttsDeltas[samples.length];
+            const ctsOffset = cttsEntries[samples.length];
+            const cts = dts + ctsOffset;
+            samples.push({
+                offset: Number(stcoBox.entries[i]) + offsetInThisChunk,
+                size,
+                isKeyframe,
+                dts,
+                cts,
+                duration: delta,
+                chunk: i,
+                bigEndian: false,
+                chunkSize: null,
+            });
+            dts += delta;
+            offsetInThisChunk += size;
+        }
+    }
+    return samples;
+};
+exports.turnSamplePositionsIntoArraySlow = turnSamplePositionsIntoArraySlow;
+const turnIntoOld = (samplePositions) => {
+    if (samplePositions.type === 'map') {
+        return (0, exports.turnSamplePositionsIntoArraySlow)({
+            ...samplePositions.boxes,
+            onlyKeyframes: false,
+        });
+    }
+    return samplePositions.boxes;
+};
+exports.turnIntoOld = turnIntoOld;
+const turnGroupIntoOld = (samplePositions) => {
+    return samplePositions.map((s) => (0, exports.turnIntoOld)(s)).flat();
+};
+exports.turnGroupIntoOld = turnGroupIntoOld;

package/dist/containers/m3u/after-manifest-fetch.d.ts

@@ -1,9 +1,11 @@
 import type { LogLevel } from '../../log';
 import type { ReaderInterface } from '../../readers/reader';
+import type { CanSkipTracksState } from '../../state/can-skip-tracks';
 import type { M3uState } from '../../state/m3u-state';
+import type { OnAudioTrack } from '../../webcodec-sample-types';
 import type { SelectM3uAssociatedPlaylistsFn, SelectM3uStreamFn } from './select-stream';
 import type { M3uStructure } from './types';
-export declare const afterManifestFetch: ({ structure, m3uState, src, selectM3uStreamFn, logLevel, selectAssociatedPlaylistsFn, readerInterface, }: {
+export declare const afterManifestFetch: ({ structure, m3uState, src, selectM3uStreamFn, logLevel, selectAssociatedPlaylistsFn, readerInterface, onAudioTrack, canSkipTracks, }: {
     structure: M3uStructure;
     m3uState: M3uState;
     src: string;
@@ -11,4 +13,6 @@ export declare const afterManifestFetch: ({ structure, m3uState, src, selectM3uS
     selectAssociatedPlaylistsFn: SelectM3uAssociatedPlaylistsFn;
     logLevel: LogLevel;
     readerInterface: ReaderInterface;
+    onAudioTrack: OnAudioTrack | null;
+    canSkipTracks: CanSkipTracksState;
 }) => Promise<void>;

package/dist/containers/m3u/after-manifest-fetch.js

@@ -5,7 +5,7 @@ const log_1 = require("../../log");
 const fetch_m3u8_stream_1 = require("./fetch-m3u8-stream");
 const get_streams_1 = require("./get-streams");
 const select_stream_1 = require("./select-stream");
-const afterManifestFetch = async ({ structure, m3uState, src, selectM3uStreamFn, logLevel, selectAssociatedPlaylistsFn, readerInterface, }) => {
+const afterManifestFetch = async ({ structure, m3uState, src, selectM3uStreamFn, logLevel, selectAssociatedPlaylistsFn, readerInterface, onAudioTrack, canSkipTracks, }) => {
     const independentSegments = (0, get_streams_1.isIndependentSegments)(structure);
     if (!independentSegments) {
         if (!src) {
@@ -29,9 +29,11 @@ const afterManifestFetch = async ({ structure, m3uState, src, selectM3uStreamFn,
         type: 'selected-stream',
         stream: selectedPlaylist,
     });
+    const skipAudioTracks = onAudioTrack === null && canSkipTracks.doFieldsNeedTracks() === false;
     const associatedPlaylists = await (0, select_stream_1.selectAssociatedPlaylists)({
         playlists: selectedPlaylist.associatedPlaylists,
         fn: selectAssociatedPlaylistsFn,
+        skipAudioTracks,
     });
     m3uState.setAssociatedPlaylists(associatedPlaylists);
     const playlistUrls = [

package/dist/containers/m3u/first-sample-in-m3u-chunk.d.ts

@@ -0,0 +1,13 @@
+import type { MediaParserController } from '../../controller/media-parser-controller';
+import type { M3uState } from '../../state/m3u-state';
+import type { AudioOrVideoSample } from '../../webcodec-sample-types';
+export declare const considerSeekBasedOnChunk: ({ sample, parentController, childController, callback, m3uState, playlistUrl, subtractChunks, chunkIndex, }: {
+    sample: AudioOrVideoSample;
+    callback: (sample: AudioOrVideoSample) => void | Promise<void>;
+    parentController: MediaParserController;
+    childController: MediaParserController;
+    playlistUrl: string;
+    m3uState: M3uState;
+    subtractChunks: number;
+    chunkIndex: number | null;
+}) => Promise<void>;

package/dist/containers/m3u/first-sample-in-m3u-chunk.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.considerSeekBasedOnChunk = void 0;
+const considerSeekBasedOnChunk = async ({ sample, parentController, childController, callback, m3uState, playlistUrl, subtractChunks, chunkIndex, }) => {
+    const pendingSeek = m3uState.getSeekToSecondsToProcess(playlistUrl);
+    // If there is not even a seek to consider, just call the callback
+    if (pendingSeek === null) {
+        await callback(sample);
+        return;
+    }
+    const timestamp = Math.min(sample.dts / sample.timescale, sample.cts / sample.timescale);
+    // Already too far, now we should go to the previous chunk
+    if (timestamp > pendingSeek.targetTime &&
+        chunkIndex !== null &&
+        chunkIndex > 0) {
+        m3uState.setNextSeekShouldSubtractChunks(playlistUrl, subtractChunks + 1);
+        parentController.seek({
+            type: 'keyframe-before-time',
+            timeInSeconds: pendingSeek.targetTime,
+        });
+        return;
+    }
+    // We are good, we have not gone too far! Don't emit sample and seek and clear pending seek
+    childController.seek({
+        type: 'keyframe-before-time',
+        timeInSeconds: pendingSeek.targetTime,
+    });
+    m3uState.setNextSeekShouldSubtractChunks(playlistUrl, 0);
+    m3uState.setSeekToSecondsToProcess(playlistUrl, null);
+};
+exports.considerSeekBasedOnChunk = considerSeekBasedOnChunk;

package/dist/containers/m3u/get-seeking-byte.d.ts

@@ -0,0 +1,13 @@
+import type { LogLevel } from '../../log';
+import type { M3uState } from '../../state/m3u-state';
+import type { SeekResolution } from '../../work-on-seek-request';
+export declare const clearM3uStateInPrepareForSeek: ({ m3uState, logLevel, }: {
+    m3uState: M3uState;
+    logLevel: LogLevel;
+}) => void;
+export declare const getSeekingByteForM3u8: ({ time, currentPosition, m3uState, logLevel, }: {
+    time: number;
+    currentPosition: number;
+    m3uState: M3uState;
+    logLevel: LogLevel;
+}) => SeekResolution;

package/dist/containers/m3u/get-seeking-byte.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSeekingByteForM3u8 = exports.clearM3uStateInPrepareForSeek = void 0;
+const log_1 = require("../../log");
+const clearM3uStateInPrepareForSeek = ({ m3uState, logLevel, }) => {
+    const selectedPlaylists = m3uState.getSelectedPlaylists();
+    for (const playlistUrl of selectedPlaylists) {
+        const streamRun = m3uState.getM3uStreamRun(playlistUrl);
+        if (streamRun) {
+            streamRun.abort();
+        }
+        log_1.Log.trace(logLevel, 'Clearing M3U stream run for', playlistUrl);
+        m3uState.setM3uStreamRun(playlistUrl, null);
+    }
+    m3uState.clearAllChunksProcessed();
+    m3uState.sampleSorter.clearSamples();
+};
+exports.clearM3uStateInPrepareForSeek = clearM3uStateInPrepareForSeek;
+const getSeekingByteForM3u8 = ({ time, currentPosition, m3uState, logLevel, }) => {
+    (0, exports.clearM3uStateInPrepareForSeek)({ m3uState, logLevel });
+    const selectedPlaylists = m3uState.getSelectedPlaylists();
+    for (const playlistUrl of selectedPlaylists) {
+        m3uState.setSeekToSecondsToProcess(playlistUrl, {
+            targetTime: time,
+        });
+    }
+    return {
+        type: 'do-seek',
+        byte: currentPosition,
+    };
+};
+exports.getSeekingByteForM3u8 = getSeekingByteForM3u8;

package/dist/containers/m3u/get-streams.d.ts

@@ -12,6 +12,7 @@ export type M3uAssociatedPlaylist = {
     channels: number | null;
     src: string;
     id: number;
+    isAudio: boolean;
 };
 export type M3uStream = {
     src: string;

package/dist/containers/m3u/get-streams.js

@@ -35,6 +35,7 @@ const getM3uStreams = ({ structure, originalSrc, readerInterface, }) => {
                         name: audioTrack.name,
                         src: readerInterface.createAdjacentFileSource(audioTrack.uri, originalSrc),
                         id: associatedPlaylists.length,
+                        isAudio: true,
                     });
                 }
             }

package/dist/containers/m3u/iterate-over-segment-files.d.ts

@@ -1,11 +1,12 @@
 import type { MediaParserController } from '../../controller/media-parser-controller';
+import type { PrefetchCache } from '../../fetch';
 import type { AudioTrack, VideoTrack } from '../../get-tracks';
 import type { LogLevel } from '../../log';
 import type { ReaderInterface } from '../../readers/reader';
-import type { ExistingM3uRun, M3uState } from '../../state/m3u-state';
+import type { M3uRun, M3uState } from '../../state/m3u-state';
 import type { OnAudioSample, OnVideoSample } from '../../webcodec-sample-types';
 import type { M3uStructure } from './types';
-export declare const iteratorOverSegmentFiles: ({ structure, onVideoTrack, m3uState, onAudioTrack, onDoneWithTracks, playlistUrl, logLevel, parentController, onInitialProgress, readerInterface, }: {
+export declare const iteratorOverSegmentFiles: ({ structure, onVideoTrack, m3uState, onAudioTrack, onDoneWithTracks, playlistUrl, logLevel, parentController, onInitialProgress, readerInterface, prefetchCache, }: {
     structure: M3uStructure;
     onVideoTrack: null | ((track: VideoTrack) => Promise<OnVideoSample | null>);
     onAudioTrack: null | ((track: AudioTrack) => Promise<OnAudioSample | null>);
@@ -14,6 +15,7 @@ export declare const iteratorOverSegmentFiles: ({ structure, onVideoTrack, m3uSt
     playlistUrl: string;
     logLevel: LogLevel;
     parentController: MediaParserController;
-    onInitialProgress: (run: ExistingM3uRun | null) => void;
+    onInitialProgress: (run: M3uRun | null) => void;
     readerInterface: ReaderInterface;
+    prefetchCache: PrefetchCache;
 }) => Promise<void>;

package/dist/containers/m3u/iterate-over-segment-files.js

@@ -7,7 +7,7 @@ const parse_media_1 = require("../../parse-media");
 const with_resolvers_1 = require("../../with-resolvers");
 const get_chunks_1 = require("./get-chunks");
 const get_playlist_1 = require("./get-playlist");
-const iteratorOverSegmentFiles = async ({ structure, onVideoTrack, m3uState, onAudioTrack, onDoneWithTracks, playlistUrl, logLevel, parentController, onInitialProgress, readerInterface, }) => {
+const iteratorOverSegmentFiles = async ({ structure, onVideoTrack, m3uState, onAudioTrack, onDoneWithTracks, playlistUrl, logLevel, parentController, onInitialProgress, readerInterface, prefetchCache, }) => {
     const playlist = (0, get_playlist_1.getPlaylist)(structure, playlistUrl);
     const chunks = (0, get_chunks_1.getChunks)(playlist);
     let resolver = onInitialProgress;
@@ -22,6 +22,16 @@ const iteratorOverSegmentFiles = async ({ structure, onVideoTrack, m3uState, onA
             childController,
             parentController,
         });
+        const nextChunk = chunks[chunks.indexOf(chunk) + 1];
+        if (nextChunk) {
+            const nextChunkSource = readerInterface.createAdjacentFileSource(nextChunk.url, playlistUrl);
+            readerInterface.preload({
+                logLevel,
+                range: null,
+                src: nextChunkSource,
+                prefetchCache,
+            });
+        }
         const makeContinuationFn = () => {
             return {
                 continue() {

package/dist/containers/m3u/parse-m3u-media-directive.js

@@ -31,6 +31,7 @@ const parseM3uMediaDirective = (str) => {
         language: map.LANGUAGE || null,
         name: map.NAME || null,
         uri: map.URI,
+        mediaType: map.TYPE || null,
     };
 };
 exports.parseM3uMediaDirective = parseM3uMediaDirective;

package/dist/containers/m3u/parse-m3u.js

@@ -21,6 +21,12 @@ const parseM3u = async ({ state }) => {
         if (typeof state.src !== 'string' && !(state.src instanceof URL)) {
             throw new Error('Expected src to be a string');
         }
+        state.mediaSection.addMediaSection({
+            start: 0,
+            // We do a pseudo-seek when seeking m3u, which will be the same byte
+            // as we are currently in, which in most cases is the end of the file.
+            size: state.contentLength + 1,
+        });
         await (0, after_manifest_fetch_1.afterManifestFetch)({
             structure,
             m3uState: state.m3u,
@@ -29,6 +35,8 @@ const parseM3u = async ({ state }) => {
             logLevel: state.logLevel,
             selectAssociatedPlaylistsFn: state.selectM3uAssociatedPlaylistsFn,
             readerInterface: state.readerInterface,
+            onAudioTrack: state.onAudioTrack,
+            canSkipTracks: state.callbacks.canSkipTracksState,
         });
         return null;
     }

package/dist/containers/m3u/process-m3u-chunk.d.ts

@@ -0,0 +1,12 @@
+import type { ParserState } from '../../state/parser-state';
+import type { M3uStructure } from './types';
+export type PendingSeek = {
+    pending: number | null;
+};
+export declare const processM3uChunk: ({ playlistUrl, state, structure, audioDone, videoDone, }: {
+    playlistUrl: string;
+    state: ParserState;
+    structure: M3uStructure;
+    audioDone: boolean;
+    videoDone: boolean;
+}) => Promise<void>;

package/dist/containers/m3u/process-m3u-chunk.js

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processM3uChunk = void 0;
+const media_parser_controller_1 = require("../../controller/media-parser-controller");
+const forward_controller_pause_resume_abort_1 = require("../../forward-controller-pause-resume-abort");
+const parse_media_1 = require("../../parse-media");
+const register_track_1 = require("../../register-track");
+const with_resolvers_1 = require("../../with-resolvers");
+const first_sample_in_m3u_chunk_1 = require("./first-sample-in-m3u-chunk");
+const get_chunks_1 = require("./get-chunks");
+const get_playlist_1 = require("./get-playlist");
+const get_chunk_to_seek_to_1 = require("./seek/get-chunk-to-seek-to");
+const processM3uChunk = ({ playlistUrl, state, structure, audioDone, videoDone, }) => {
+    const { promise, reject, resolve } = (0, with_resolvers_1.withResolvers)();
+    const onGlobalAudioTrack = audioDone
+        ? null
+        : async (track) => {
+            const existingTracks = state.callbacks.tracks.getTracks();
+            let { trackId } = track;
+            while (existingTracks.find((t) => t.trackId === trackId)) {
+                trackId++;
+            }
+            const onAudioSample = await (0, register_track_1.registerAudioTrack)({
+                container: 'm3u8',
+                track: {
+                    ...track,
+                    trackId,
+                },
+                registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
+                tracks: state.callbacks.tracks,
+                logLevel: state.logLevel,
+                onAudioTrack: state.onAudioTrack,
+            });
+            state.m3u.sampleSorter.addToStreamWithTrack(playlistUrl);
+            if (onAudioSample === null) {
+                return null;
+            }
+            state.m3u.sampleSorter.addAudioStreamToConsider(playlistUrl, onAudioSample);
+            return async (sample) => {
+                await state.m3u.sampleSorter.addAudioSample(playlistUrl, sample);
+            };
+        };
+    const onGlobalVideoTrack = videoDone
+        ? null
+        : async (track) => {
+            const existingTracks = state.callbacks.tracks.getTracks();
+            let { trackId } = track;
+            while (existingTracks.find((t) => t.trackId === trackId)) {
+                trackId++;
+            }
+            const onVideoSample = await (0, register_track_1.registerVideoTrack)({
+                container: 'm3u8',
+                track: {
+                    ...track,
+                    trackId,
+                },
+                logLevel: state.logLevel,
+                onVideoTrack: state.onVideoTrack,
+                registerVideoSampleCallback: state.callbacks.registerVideoSampleCallback,
+                tracks: state.callbacks.tracks,
+            });
+            state.m3u.sampleSorter.addToStreamWithTrack(playlistUrl);
+            if (onVideoSample === null) {
+                return null;
+            }
+            state.m3u.sampleSorter.addVideoStreamToConsider(playlistUrl, onVideoSample);
+            return async (sample) => {
+                await state.m3u.sampleSorter.addVideoSample(playlistUrl, sample);
+            };
+        };
+    // This function will run through the whole playlist step by step, and pause itself
+    // On the next run it will continue
+    const pausableIterator = async () => {
+        const playlist = (0, get_playlist_1.getPlaylist)(structure, playlistUrl);
+        const chunks = (0, get_chunks_1.getChunks)(playlist);
+        const seekToSecondsToProcess = state.m3u.getSeekToSecondsToProcess(playlistUrl);
+        const chunksToSubtract = state.m3u.getNextSeekShouldSubtractChunks(playlistUrl);
+        let chunkIndex = null;
+        if (seekToSecondsToProcess !== null) {
+            chunkIndex = Math.max(0, (0, get_chunk_to_seek_to_1.getChunkToSeekTo)({
+                chunks,
+                seekToSecondsToProcess: seekToSecondsToProcess.targetTime,
+            }) - chunksToSubtract);
+        }
+        const currentPromise = {
+            resolver: (() => undefined),
+            rejector: reject,
+        };
+        const requiresHeaderToBeFetched = chunks[0].isHeader;
+        for (const chunk of chunks) {
+            const mp4HeaderSegment = state.m3u.getMp4HeaderSegment(playlistUrl);
+            if (requiresHeaderToBeFetched && mp4HeaderSegment && chunk.isHeader) {
+                continue;
+            }
+            if (chunkIndex !== null &&
+                chunks.indexOf(chunk) < chunkIndex &&
+                !chunk.isHeader) {
+                continue;
+            }
+            currentPromise.resolver = (newRun) => {
+                state.m3u.setM3uStreamRun(playlistUrl, newRun);
+                resolve();
+            };
+            currentPromise.rejector = reject;
+            const childController = (0, media_parser_controller_1.mediaParserController)();
+            const forwarded = (0, forward_controller_pause_resume_abort_1.forwardMediaParserControllerPauseResume)({
+                childController,
+                parentController: state.controller,
+            });
+            const nextChunk = chunks[chunks.indexOf(chunk) + 1];
+            if (nextChunk) {
+                const nextChunkSource = state.readerInterface.createAdjacentFileSource(nextChunk.url, playlistUrl);
+                state.readerInterface.preload({
+                    logLevel: state.logLevel,
+                    range: null,
+                    src: nextChunkSource,
+                    prefetchCache: state.prefetchCache,
+                });
+            }
+            const makeContinuationFn = () => {
+                return {
+                    continue() {
+                        const resolver = (0, with_resolvers_1.withResolvers)();
+                        currentPromise.resolver = resolver.resolve;
+                        currentPromise.rejector = resolver.reject;
+                        childController.resume();
+                        return resolver.promise;
+                    },
+                    abort() {
+                        childController.abort();
+                    },
+                };
+            };
+            const isLastChunk = chunk === chunks[chunks.length - 1];
+            await childController._internals.checkForAbortAndPause();
+            const src = state.readerInterface.createAdjacentFileSource(chunk.url, playlistUrl);
+            try {
+                const data = await (0, parse_media_1.parseMedia)({
+                    src,
+                    acknowledgeRemotionLicense: true,
+                    logLevel: state.logLevel,
+                    controller: childController,
+                    progressIntervalInMs: 0,
+                    onParseProgress: () => {
+                        childController.pause();
+                        currentPromise.resolver(makeContinuationFn());
+                    },
+                    fields: chunk.isHeader ? { structure: true } : undefined,
+                    onTracks: () => {
+                        if (!state.m3u.hasEmittedDoneWithTracks(playlistUrl)) {
+                            state.m3u.setHasEmittedDoneWithTracks(playlistUrl);
+                            const allDone = state.m3u.setTracksDone(playlistUrl);
+                            if (allDone) {
+                                state.callbacks.tracks.setIsDone(state.logLevel);
+                            }
+                            return null;
+                        }
+                    },
+                    onAudioTrack: onGlobalAudioTrack === null
+                        ? null
+                        : async ({ track }) => {
+                            const callbackOrFalse = state.m3u.hasEmittedAudioTrack(playlistUrl);
+                            if (callbackOrFalse === false) {
+                                const callback = await onGlobalAudioTrack(track);
+                                if (!callback) {
+                                    state.m3u.setHasEmittedAudioTrack(playlistUrl, null);
+                                    return null;
+                                }
+                                state.m3u.setHasEmittedAudioTrack(playlistUrl, callback);
+                                return async (sample) => {
+                                    await (0, first_sample_in_m3u_chunk_1.considerSeekBasedOnChunk)({
+                                        sample,
+                                        callback,
+                                        parentController: state.controller,
+                                        childController,
+                                        m3uState: state.m3u,
+                                        playlistUrl,
+                                        subtractChunks: chunksToSubtract,
+                                        chunkIndex,
+                                    });
+                                };
+                            }
+                            if (callbackOrFalse === null) {
+                                return null;
+                            }
+                            return async (sample) => {
+                                await (0, first_sample_in_m3u_chunk_1.considerSeekBasedOnChunk)({
+                                    sample,
+                                    m3uState: state.m3u,
+                                    playlistUrl,
+                                    callback: callbackOrFalse,
+                                    parentController: state.controller,
+                                    childController,
+                                    subtractChunks: chunksToSubtract,
+                                    chunkIndex,
+                                });
+                            };
+                        },
+                    onVideoTrack: onGlobalVideoTrack === null
+                        ? null
+                        : async ({ track }) => {
+                            const callbackOrFalse = state.m3u.hasEmittedVideoTrack(playlistUrl);
+                            if (callbackOrFalse === false) {
+                                const callback = await onGlobalVideoTrack({
+                                    ...track,
+                                    m3uStreamFormat: chunk.isHeader || mp4HeaderSegment ? 'mp4' : 'ts',
+                                });
+                                if (!callback) {
+                                    state.m3u.setHasEmittedVideoTrack(playlistUrl, null);
+                                    return null;
+                                }
+                                state.m3u.setHasEmittedVideoTrack(playlistUrl, callback);
+                                return async (sample) => {
+                                    await (0, first_sample_in_m3u_chunk_1.considerSeekBasedOnChunk)({
+                                        sample,
+                                        m3uState: state.m3u,
+                                        playlistUrl,
+                                        callback,
+                                        parentController: state.controller,
+                                        childController,
+                                        subtractChunks: chunksToSubtract,
+                                        chunkIndex,
+                                    });
+                                };
+                            }
+                            if (callbackOrFalse === null) {
+                                return null;
+                            }
+                            return async (sample) => {
+                                await (0, first_sample_in_m3u_chunk_1.considerSeekBasedOnChunk)({
+                                    sample,
+                                    m3uState: state.m3u,
+                                    playlistUrl,
+                                    callback: callbackOrFalse,
+                                    parentController: state.controller,
+                                    childController,
+                                    subtractChunks: chunksToSubtract,
+                                    chunkIndex,
+                                });
+                            };
+                        },
+                    reader: state.readerInterface,
+                    makeSamplesStartAtZero: false,
+                    m3uPlaylistContext: {
+                        mp4HeaderSegment,
+                        isLastChunkInPlaylist: isLastChunk,
+                    },
+                });
+                if (chunk.isHeader) {
+                    if (data.structure.type !== 'iso-base-media') {
+                        throw new Error('Expected an mp4 file');
+                    }
+                    state.m3u.setMp4HeaderSegment(playlistUrl, data.structure);
+                }
+            }
+            catch (e) {
+                currentPromise.rejector(e);
+                throw e;
+            }
+            forwarded.cleanup();
+            if (!isLastChunk) {
+                childController.pause();
+                currentPromise.resolver(makeContinuationFn());
+            }
+        }
+        currentPromise.resolver(null);
+    };
+    const run = pausableIterator();
+    run.catch((err) => {
+        reject(err);
+    });
+    return promise;
+};
+exports.processM3uChunk = processM3uChunk;