@remotion/media-parser 4.0.298 → 4.0.301

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

package/dist/containers/iso-base-media/sample-positions.d.ts

@@ -1,25 +0,0 @@
-import type { SamplePosition } from '../../get-sample-positions';
-import type { CttsBox } from './stsd/ctts';
-import type { StcoBox } from './stsd/stco';
-import type { StscBox } from './stsd/stsc';
-import type { StssBox } from './stsd/stss';
-import type { StszBox } from './stsd/stsz';
-import type { SttsBox } from './stsd/stts';
-export type GroupOfSamplePositions = {
-    type: 'array';
-    boxes: SamplePosition[];
-} | {
-    type: 'map';
-    boxes: {
-        stszBox: StszBox;
-        stcoBox: StcoBox;
-        stscBox: StscBox;
-        sttsBox: SttsBox;
-        stssBox: StssBox | null;
-        cttsBox: CttsBox | null;
-    };
-};
-export declare const hasNoSamplePositions: (samplePositions: GroupOfSamplePositions) => boolean;
-export declare const hasNoSamplePositionsGroup: (samplePositions: GroupOfSamplePositions[]) => boolean;
-export declare const getKeyframesFromGroupOfSamplePositions: (samplePositions: GroupOfSamplePositions) => SamplePosition[];
-export declare const groupGetKeyframesFromGroupOfSamplePositions: (samplePositions: GroupOfSamplePositions[]) => SamplePosition[];

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

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.groupGetKeyframesFromGroupOfSamplePositions = exports.getKeyframesFromGroupOfSamplePositions = exports.hasNoSamplePositionsGroup = exports.hasNoSamplePositions = void 0;
-const turn_sample_positions_into_array_1 = require("./turn-sample-positions-into-array");
-const hasNoSamplePositions = (samplePositions) => {
-    if (samplePositions.type === 'array') {
-        return samplePositions.boxes.length === 0;
-    }
-    return samplePositions.boxes.stcoBox.entryCount === 0;
-};
-exports.hasNoSamplePositions = hasNoSamplePositions;
-const hasNoSamplePositionsGroup = (samplePositions) => {
-    return samplePositions.every((s) => (0, exports.hasNoSamplePositions)(s));
-};
-exports.hasNoSamplePositionsGroup = hasNoSamplePositionsGroup;
-const getKeyframesFromGroupOfSamplePositions = (samplePositions) => {
-    if (samplePositions.type === 'array') {
-        return samplePositions.boxes.filter((s) => s.isKeyframe);
-    }
-    if (!samplePositions.boxes.stssBox) {
-        return (0, turn_sample_positions_into_array_1.turnSamplePositionsIntoArraySlow)({
-            ...samplePositions.boxes,
-            onlyKeyframes: true,
-        });
-    }
-    return (0, turn_sample_positions_into_array_1.turnSamplePositionsIntoArraySlow)({
-        ...samplePositions.boxes,
-        onlyKeyframes: false,
-    });
-};
-exports.getKeyframesFromGroupOfSamplePositions = getKeyframesFromGroupOfSamplePositions;
-const groupGetKeyframesFromGroupOfSamplePositions = (samplePositions) => {
-    return samplePositions
-        .map((s) => (0, exports.getKeyframesFromGroupOfSamplePositions)(s))
-        .flat();
-};
-exports.groupGetKeyframesFromGroupOfSamplePositions = groupGetKeyframesFromGroupOfSamplePositions;

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

@@ -1,19 +0,0 @@
-import type { SamplePosition } from '../../get-sample-positions';
-import type { GroupOfSamplePositions } from './sample-positions';
-import type { CttsBox } from './stsd/ctts';
-import type { StcoBox } from './stsd/stco';
-import type { StscBox } from './stsd/stsc';
-import type { StssBox } from './stsd/stss';
-import type { StszBox } from './stsd/stsz';
-import type { SttsBox } from './stsd/stts';
-export declare const turnSamplePositionsIntoArraySlow: ({ stcoBox, stszBox, stscBox, stssBox, sttsBox, cttsBox, onlyKeyframes, }: {
-    stcoBox: StcoBox;
-    stszBox: StszBox;
-    stscBox: StscBox;
-    stssBox: StssBox | null;
-    sttsBox: SttsBox;
-    cttsBox: CttsBox | null;
-    onlyKeyframes: boolean;
-}) => SamplePosition[];
-export declare const turnIntoOld: (samplePositions: GroupOfSamplePositions) => SamplePosition[];
-export declare const turnGroupIntoOld: (samplePositions: GroupOfSamplePositions[]) => SamplePosition[];

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

@@ -1,73 +0,0 @@
-"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/iterate-over-segment-files.d.ts

@@ -1,21 +0,0 @@
-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 { 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, prefetchCache, }: {
-    structure: M3uStructure;
-    onVideoTrack: null | ((track: VideoTrack) => Promise<OnVideoSample | null>);
-    onAudioTrack: null | ((track: AudioTrack) => Promise<OnAudioSample | null>);
-    onDoneWithTracks: () => void;
-    m3uState: M3uState;
-    playlistUrl: string;
-    logLevel: LogLevel;
-    parentController: MediaParserController;
-    onInitialProgress: (run: M3uRun | null) => void;
-    readerInterface: ReaderInterface;
-    prefetchCache: PrefetchCache;
-}) => Promise<void>;