@remotion/media-parser 4.0.298 → 4.0.300

package/dist/add-avc-profile-to-track.d.ts

@@ -1,3 +1,3 @@
-import type { VideoTrack } from './get-tracks';
+import type { MediaParserVideoTrack } from './get-tracks';
 import type { SpsAndPps } from './state/parser-state';
-export declare const addAvcProfileToTrack: (track: VideoTrack, avc1Profile: SpsAndPps | null) => VideoTrack;
+export declare const addAvcProfileToTrack: (track: MediaParserVideoTrack, avc1Profile: SpsAndPps | null) => MediaParserVideoTrack;

package/dist/add-avc-profile-to-track.js

@@ -10,7 +10,13 @@ const addAvcProfileToTrack = (track, avc1Profile) => {
     return {
         ...track,
         codec: (0, codec_string_1.getCodecStringFromSpsAndPps)(avc1Profile.sps),
-        codecPrivate: (0, create_sps_pps_data_1.createSpsPpsData)(avc1Profile),
+        codecData: { type: 'avc-sps-pps', data: (0, create_sps_pps_data_1.createSpsPpsData)(avc1Profile) },
+        // description should be undefined, since this signals to WebCodecs that
+        // the codec is in Annex B format, which is the case for AVI files
+        // https://www.w3.org/TR/webcodecs-avc-codec-registration/#videodecoderconfig-description
+        // ChatGPT 4.1: "Great question! The format of the H.264/AVC bitstream inside a ⁠.avi file is almost always in the "Annex B" format"
+        // (description is probably already undefined at this point, just writing this to be explicit)
+        description: undefined,
     };
 };
 exports.addAvcProfileToTrack = addAvcProfileToTrack;

package/dist/codec-data.d.ts

@@ -0,0 +1,29 @@
+export type MediaParserAvcSppData = {
+    type: 'avc-sps-pps';
+    data: Uint8Array;
+};
+export type MediaParserHvccData = {
+    type: 'hvcc-data';
+    data: Uint8Array;
+};
+export type MediaParserAv1cData = {
+    type: 'av1c-data';
+    data: Uint8Array;
+};
+export type MediaParserAacConfig = {
+    type: 'aac-config';
+    data: Uint8Array;
+};
+export type MediaParserFlacDescription = {
+    type: 'flac-description';
+    data: Uint8Array;
+};
+export type UnknownCodecData = {
+    type: 'unknown-data';
+    data: Uint8Array;
+};
+export type MediaParserOggIdentification = {
+    type: 'ogg-identification';
+    data: Uint8Array;
+};
+export type MediaParserCodecData = MediaParserAvcSppData | MediaParserHvccData | MediaParserAv1cData | MediaParserAacConfig | MediaParserFlacDescription | MediaParserOggIdentification | UnknownCodecData;

package/dist/codec-data.js

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

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

@@ -54,14 +54,13 @@ const parseAac = async (state) => {
             container: 'aac',
             track: {
                 codec: (0, aac_codecprivate_1.mapAudioObjectTypeToCodecString)(audioObjectType),
-                codecWithoutConfig: 'aac',
-                codecPrivate,
+                codecEnum: 'aac',
+                codecData: { type: 'aac-config', data: codecPrivate },
                 description: codecPrivate,
                 numberOfChannels: channelConfiguration,
                 sampleRate,
                 timescale: 1000000,
                 trackId: 0,
-                trakBox: null,
                 type: 'audio',
             },
             registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,

package/dist/containers/avc/color.d.ts

@@ -1,6 +1,6 @@
-export type MatrixCoefficients = 'bt709' | 'bt470bg' | 'rgb' | 'smpte170m' | 'bt2020';
-export declare const getMatrixCoefficientsFromIndex: (index: number) => MatrixCoefficients | null;
-export type TransferCharacteristics = 'bt709' | 'smpte170m' | 'iec61966-2-1' | 'arib-std-b67';
-export declare const getTransferCharacteristicsFromIndex: (index: number) => TransferCharacteristics | null;
-export type Primaries = 'bt709' | 'smpte170m' | 'bt470bg' | 'bt2020' | null;
-export declare const getPrimariesFromIndex: (index: number) => Primaries | null;
+export type MediaParserMatrixCoefficients = 'rgb' | 'bt709' | 'bt470bg' | 'smpte170m' | 'bt2020-ncl';
+export declare const getMatrixCoefficientsFromIndex: (index: number) => MediaParserMatrixCoefficients | null;
+export type MediaParserTransferCharacteristics = 'bt709' | 'smpte170m' | 'iec61966-2-1' | 'linear' | 'pq' | 'hlg';
+export declare const getTransferCharacteristicsFromIndex: (index: number) => MediaParserTransferCharacteristics | null;
+export type MediaParserPrimaries = 'bt709' | 'bt470bg' | 'smpte170m' | 'bt2020' | 'smpte432' | null;
+export declare const getPrimariesFromIndex: (index: number) => MediaParserPrimaries | null;

package/dist/containers/avc/color.js

@@ -2,38 +2,64 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPrimariesFromIndex = exports.getTransferCharacteristicsFromIndex = exports.getMatrixCoefficientsFromIndex = void 0;
 const getMatrixCoefficientsFromIndex = (index) => {
-    return index === 1
-        ? 'bt709'
-        : index === 5
-            ? 'bt470bg'
-            : index === 6
-                ? 'smpte170m'
-                : index === 9
-                    ? 'bt2020'
-                    : null;
+    if (index === 0) {
+        return 'rgb';
+    }
+    if (index === 1) {
+        return 'bt709';
+    }
+    if (index === 5) {
+        return 'bt470bg';
+    }
+    if (index === 6) {
+        return 'smpte170m';
+    }
+    if (index === 9) {
+        return 'bt2020-ncl';
+    }
+    return null;
 };
 exports.getMatrixCoefficientsFromIndex = getMatrixCoefficientsFromIndex;
+// https://w3c.github.io/webcodecs/#videotransfercharacteristics
+// But we may support more than that
 const getTransferCharacteristicsFromIndex = (index) => {
-    return index === 1
-        ? 'bt709'
-        : index === 6
-            ? 'smpte170m'
-            : index === 13
-                ? 'iec61966-2-1'
-                : index === 18
-                    ? 'arib-std-b67'
-                    : null;
+    if (index === 1) {
+        return 'bt709';
+    }
+    if (index === 6) {
+        return 'smpte170m';
+    }
+    if (index === 8) {
+        return 'linear';
+    }
+    if (index === 13) {
+        return 'iec61966-2-1';
+    }
+    if (index === 16) {
+        return 'pq';
+    }
+    if (index === 18) {
+        return 'hlg';
+    }
+    return null;
 };
 exports.getTransferCharacteristicsFromIndex = getTransferCharacteristicsFromIndex;
 const getPrimariesFromIndex = (index) => {
-    return index === 1
-        ? 'bt709'
-        : index === 5
-            ? 'bt470bg'
-            : index === 6
-                ? 'smpte170m'
-                : index === 9
-                    ? 'bt2020'
-                    : null;
+    if (index === 1) {
+        return 'bt709';
+    }
+    if (index === 5) {
+        return 'bt470bg';
+    }
+    if (index === 6) {
+        return 'smpte170m';
+    }
+    if (index === 9) {
+        return 'bt2020';
+    }
+    if (index === 12) {
+        return 'smpte432';
+    }
+    return null;
 };
 exports.getPrimariesFromIndex = getPrimariesFromIndex;

package/dist/containers/avc/create-avc-decoder-configuration-record.d.ts

@@ -0,0 +1,2 @@
+import type { SpsAndPps } from '../../state/parser-state';
+export declare const createAVCDecoderConfigurationRecord: (avc1Profile: SpsAndPps) => Uint8Array<ArrayBufferLike>;

package/dist/containers/avc/create-avc-decoder-configuration-record.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAVCDecoderConfigurationRecord = void 0;
+const combine_uint8_arrays_1 = require("../../combine-uint8-arrays");
+const truthy_1 = require("../../truthy");
+function serializeUint16(value) {
+    const buffer = new ArrayBuffer(2);
+    const view = new DataView(buffer);
+    view.setUint16(0, value);
+    return new Uint8Array(buffer);
+}
+const createAVCDecoderConfigurationRecord = (avc1Profile) => {
+    return (0, combine_uint8_arrays_1.combineUint8Arrays)([
+        new Uint8Array([
+            // https://gist.github.com/uupaa/8493378ec15f644a3d2b
+            1, // version
+            avc1Profile.sps.spsData.profile,
+            avc1Profile.sps.spsData.compatibility,
+            avc1Profile.sps.spsData.level,
+            0xff,
+            0xe1,
+        ]),
+        // sequence parameter set length
+        serializeUint16(avc1Profile.sps.sps.length),
+        // sequence parameter set
+        avc1Profile.sps.sps,
+        // num of PPS
+        new Uint8Array([0x01]),
+        // picture parameter set length
+        serializeUint16(avc1Profile.pps.pps.length),
+        // PPS
+        avc1Profile.pps.pps,
+    ].filter(truthy_1.truthy));
+};
+exports.createAVCDecoderConfigurationRecord = createAVCDecoderConfigurationRecord;

package/dist/containers/avc/interpret-sps.d.ts

@@ -1,4 +1,4 @@
-import type { VideoTrackColorParams } from '../../get-tracks';
+import type { MediaParserAdvancedColor } from '../../get-tracks';
 import type { SpsInfo } from './parse-avc';
 export declare const getDimensionsFromSps: (sps: SpsInfo) => {
     height: number;
@@ -8,4 +8,4 @@ export declare const getSampleAspectRatioFromSps: (sps: SpsInfo) => {
     width: number;
     height: number;
 };
-export declare const getVideoColorFromSps: (sps: SpsInfo) => VideoTrackColorParams;
+export declare const getVideoColorFromSps: (sps: SpsInfo) => MediaParserAdvancedColor;

package/dist/containers/avc/interpret-sps.js

@@ -37,10 +37,10 @@ const getVideoColorFromSps = (sps) => {
     const transferCharacteristics = (_b = sps.vui_parameters) === null || _b === void 0 ? void 0 : _b.transfer_characteristics;
     const colorPrimaries = (_c = sps.vui_parameters) === null || _c === void 0 ? void 0 : _c.colour_primaries;
     return {
-        matrixCoefficients: matrixCoefficients
+        matrix: matrixCoefficients
             ? (0, color_1.getMatrixCoefficientsFromIndex)(matrixCoefficients)
             : null,
-        transferCharacteristics: transferCharacteristics
+        transfer: transferCharacteristics
             ? (0, color_1.getTransferCharacteristicsFromIndex)(transferCharacteristics)
             : null,
         primaries: colorPrimaries ? (0, color_1.getPrimariesFromIndex)(colorPrimaries) : null,

package/dist/containers/flac/parse-streaminfo.js

@@ -37,13 +37,12 @@ const parseStreamInfo = async ({ iterator, state, }) => {
             codec: 'flac',
             type: 'audio',
             description: asUint8Array,
-            codecPrivate: asUint8Array,
-            codecWithoutConfig: 'flac',
+            codecData: { type: 'flac-description', data: asUint8Array },
+            codecEnum: 'flac',
             numberOfChannels: channels,
             sampleRate,
             timescale: 1000000,
             trackId: 0,
-            trakBox: null,
         },
         registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
         tracks: state.callbacks.tracks,

package/dist/containers/iso-base-media/collect-sample-positions-from-moof-boxes.d.ts

@@ -7,7 +7,7 @@ export declare const collectSamplePositionsFromMoofBoxes: ({ moofBoxes, tkhdBox,
 }) => {
     samplePositions: {
         isLastFragment: boolean;
-        samples: import("../..").SamplePosition[];
+        samples: import("../../get-sample-positions").SamplePosition[];
     }[];
     isComplete: boolean;
 };

package/dist/containers/iso-base-media/color-to-webcodecs-colors.d.ts

@@ -0,0 +1,2 @@
+import type { MediaParserAdvancedColor } from '../../get-tracks';
+export declare const mediaParserAdvancedColorToWebCodecsColor: (color: MediaParserAdvancedColor) => VideoColorSpaceInit;

package/dist/containers/iso-base-media/color-to-webcodecs-colors.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mediaParserAdvancedColorToWebCodecsColor = void 0;
+const mediaParserAdvancedColorToWebCodecsColor = (color) => {
+    return {
+        transfer: color.transfer,
+        matrix: color.matrix,
+        primaries: color.primaries,
+        fullRange: color.fullRange,
+    };
+};
+exports.mediaParserAdvancedColorToWebCodecsColor = mediaParserAdvancedColorToWebCodecsColor;

package/dist/containers/iso-base-media/find-keyframe-before-time.d.ts

@@ -1,10 +1,10 @@
 import type { SamplePosition } from '../../get-sample-positions';
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } from '../../log';
 import type { MediaSection } from '../../state/video-section';
 export declare const findKeyframeBeforeTime: ({ samplePositions, time, timescale, mediaSections, logLevel, }: {
     samplePositions: SamplePosition[];
     time: number;
     timescale: number;
     mediaSections: MediaSection[];
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
 }) => number | null;

package/dist/containers/iso-base-media/find-track-to-seek.d.ts

@@ -1,14 +1,14 @@
 import type { SamplePosition } from '../../get-sample-positions';
-import type { AudioTrack, OtherTrack, VideoTrack } from '../../get-tracks';
+import type { MediaParserAudioTrack, MediaParserOtherTrack, MediaParserVideoTrack } from '../../get-tracks';
 import type { IsoBaseMediaStructure } from '../../parse-result';
 import type { StructureState } from '../../state/structure';
-export declare const findAnyTrackWithSamplePositions: (allTracks: (VideoTrack | AudioTrack | OtherTrack)[], struc: IsoBaseMediaStructure) => {
-    track: VideoTrack | AudioTrack;
+export declare const findAnyTrackWithSamplePositions: (allTracks: (MediaParserVideoTrack | MediaParserAudioTrack | MediaParserOtherTrack)[], struc: IsoBaseMediaStructure) => {
+    track: MediaParserVideoTrack | MediaParserAudioTrack;
     samplePositions: SamplePosition[];
 } | null;
 type TrackWithSamplePositions = {
-    track: VideoTrack | AudioTrack;
+    track: MediaParserVideoTrack | MediaParserAudioTrack;
     samplePositions: SamplePosition[];
 };
-export declare const findTrackToSeek: (allTracks: (VideoTrack | AudioTrack | OtherTrack)[], structure: StructureState) => TrackWithSamplePositions | null;
+export declare const findTrackToSeek: (allTracks: (MediaParserVideoTrack | MediaParserAudioTrack | MediaParserOtherTrack)[], structure: StructureState) => TrackWithSamplePositions | null;
 export {};

package/dist/containers/iso-base-media/find-track-to-seek.js

@@ -5,10 +5,18 @@ const are_samples_complete_1 = require("./are-samples-complete");
 const get_sample_positions_from_track_1 = require("./get-sample-positions-from-track");
 const traversal_1 = require("./traversal");
 const findAnyTrackWithSamplePositions = (allTracks, struc) => {
+    const moov = (0, traversal_1.getMoovFromFromIsoStructure)(struc);
+    if (!moov) {
+        return null;
+    }
     for (const track of allTracks) {
         if (track.type === 'video' || track.type === 'audio') {
+            const trakBox = (0, traversal_1.getTrakBoxByTrackId)(moov, track.trackId);
+            if (!trakBox) {
+                continue;
+            }
             const { samplePositions } = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)({
-                trakBox: track.trakBox,
+                trakBox,
                 moofBoxes: (0, traversal_1.getMoofBoxes)(struc.boxes),
                 moofComplete: (0, are_samples_complete_1.areSamplesComplete)({
                     moofBoxes: (0, traversal_1.getMoofBoxes)(struc.boxes),
@@ -30,8 +38,16 @@ const findTrackToSeek = (allTracks, structure) => {
     if (!firstVideoTrack) {
         return (0, exports.findAnyTrackWithSamplePositions)(allTracks, struc);
     }
+    const moov = (0, traversal_1.getMoovFromFromIsoStructure)(struc);
+    if (!moov) {
+        return null;
+    }
+    const trakBox = (0, traversal_1.getTrakBoxByTrackId)(moov, firstVideoTrack.trackId);
+    if (!trakBox) {
+        return null;
+    }
     const { samplePositions } = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)({
-        trakBox: firstVideoTrack.trakBox,
+        trakBox,
         moofBoxes: (0, traversal_1.getMoofBoxes)(struc.boxes),
         moofComplete: (0, are_samples_complete_1.areSamplesComplete)({
             moofBoxes: (0, traversal_1.getMoofBoxes)(struc.boxes),

package/dist/containers/iso-base-media/get-actual-number-of-channels.d.ts

@@ -1,12 +1,13 @@
+import type { MediaParserCodecData } from '../../codec-data';
 import type { MediaParserAudioCodec } from '../../get-tracks';
 type AudioDecoderConfig = {
     numberOfChannels: number;
     sampleRate: number;
-    codecPrivate: Uint8Array | null;
+    codecPrivate: MediaParserCodecData | null;
 };
 export declare const getActualDecoderParameters: ({ audioCodec, codecPrivate, numberOfChannels, sampleRate, }: {
     audioCodec: MediaParserAudioCodec;
-    codecPrivate: Uint8Array | null;
+    codecPrivate: MediaParserCodecData | null;
     numberOfChannels: number;
     sampleRate: number;
 }) => AudioDecoderConfig;

package/dist/containers/iso-base-media/get-actual-number-of-channels.js

@@ -7,16 +7,27 @@ const aac_codecprivate_1 = require("../../aac-codecprivate");
 // Therefore, prioritizing Codec Private over `numberOfChannels`.
 const getActualDecoderParameters = ({ audioCodec, codecPrivate, numberOfChannels, sampleRate, }) => {
     if (audioCodec !== 'aac') {
-        return { numberOfChannels, sampleRate, codecPrivate };
+        return {
+            numberOfChannels,
+            sampleRate,
+            codecPrivate,
+        };
     }
     if (codecPrivate === null) {
         return { numberOfChannels, sampleRate, codecPrivate };
     }
-    const parsed = (0, aac_codecprivate_1.parseAacCodecPrivate)(codecPrivate);
+    if (codecPrivate.type !== 'aac-config') {
+        throw new Error('Expected AAC codec private data');
+    }
+    const parsed = (0, aac_codecprivate_1.parseAacCodecPrivate)(codecPrivate.data);
+    const actual = (0, aac_codecprivate_1.createAacCodecPrivate)({
+        ...parsed,
+        codecPrivate: codecPrivate.data,
+    });
     return {
         numberOfChannels: parsed.channelConfiguration,
         sampleRate: parsed.sampleRate,
-        codecPrivate: (0, aac_codecprivate_1.createAacCodecPrivate)({ ...parsed, codecPrivate }),
+        codecPrivate: { type: 'aac-config', data: actual },
     };
 };
 exports.getActualDecoderParameters = getActualDecoderParameters;

package/dist/containers/iso-base-media/get-children.d.ts

@@ -1,11 +1,11 @@
 import type { BufferIterator } from '../../iterator/buffer-iterator';
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } from '../../log';
 import type { IsoBaseMediaBox } from './base-media-box';
 import type { OnlyIfMoovAtomExpected } from './process-box';
 export declare const getIsoBaseMediaChildren: ({ size, iterator, logLevel, onlyIfMoovAtomExpected, contentLength, }: {
     size: number;
     iterator: BufferIterator;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     onlyIfMoovAtomExpected: OnlyIfMoovAtomExpected | null;
     contentLength: number;
 }) => Promise<IsoBaseMediaBox[]>;

package/dist/containers/iso-base-media/get-keyframes.js

@@ -6,19 +6,28 @@ const are_samples_complete_1 = require("./are-samples-complete");
 const get_sample_positions_from_track_1 = require("./get-sample-positions-from-track");
 const traversal_1 = require("./traversal");
 const getKeyframesFromIsoBaseMedia = (state) => {
-    const { videoTracks } = (0, get_tracks_1.getTracksFromIsoBaseMedia)({
+    const tracks = (0, get_tracks_1.getTracksFromIsoBaseMedia)({
         isoState: state.iso,
         m3uPlaylistContext: state.m3uPlaylistContext,
         structure: state.structure,
         mayUsePrecomputed: true,
     });
+    const videoTracks = tracks.filter((t) => t.type === 'video');
     const structure = state.structure.getIsoStructure();
     const moofBoxes = (0, traversal_1.getMoofBoxes)(structure.boxes);
     const tfraBoxes = (0, traversal_1.getTfraBoxes)(structure.boxes);
+    const moov = (0, traversal_1.getMoovFromFromIsoStructure)(structure);
+    if (!moov) {
+        return [];
+    }
     const allSamples = videoTracks.map((t) => {
         const { timescale: ts } = t;
+        const trakBox = (0, traversal_1.getTrakBoxByTrackId)(moov, t.trackId);
+        if (!trakBox) {
+            return [];
+        }
         const { samplePositions, isComplete } = (0, get_sample_positions_from_track_1.getSamplePositionsFromTrack)({
-            trakBox: t.trakBox,
+            trakBox,
             moofBoxes,
             moofComplete: (0, are_samples_complete_1.areSamplesComplete)({
                 moofBoxes,

package/dist/containers/iso-base-media/get-mfra-seeking-box.d.ts

@@ -1,15 +1,15 @@
 import type { MediaParserController } from '../../controller/media-parser-controller';
 import type { PrefetchCache } from '../../fetch';
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } from '../../log';
 import type { ParseMediaSrc } from '../../options';
-import type { ReaderInterface } from '../../readers/reader';
+import type { MediaParserReaderInterface } from '../../readers/reader';
 import type { IsoBaseMediaBox } from './base-media-box';
 export type MfraSeekingBoxOptions = {
     contentLength: number;
     controller: MediaParserController;
-    readerInterface: ReaderInterface;
+    readerInterface: MediaParserReaderInterface;
     src: ParseMediaSrc;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     prefetchCache: PrefetchCache;
 };
 export declare const getMfraSeekingBox: ({ contentLength, controller, readerInterface, src, logLevel, prefetchCache, }: MfraSeekingBoxOptions) => Promise<IsoBaseMediaBox[] | null>;

package/dist/containers/iso-base-media/get-moov-atom.js

@@ -67,7 +67,7 @@ const getMoovAtom = async ({ endOfMdat, state, }) => {
     const boxes = [];
     const canSkipTracksState = (0, can_skip_tracks_1.makeCanSkipTracksState)({
         hasAudioTrackHandlers: false,
-        fields: { structure: true },
+        fields: { slowStructure: true },
         hasVideoTrackHandlers: false,
         structure: (0, structure_1.structureState)(),
     });

package/dist/containers/iso-base-media/get-seeking-byte-from-fragmented-mp4.d.ts

@@ -1,14 +1,18 @@
-import type { AudioTrack, OtherTrack, VideoTrack } from '../../get-tracks';
-import type { LogLevel } from '../../log';
+import type { MediaParserTrack } from '../../get-tracks';
+import type { MediaParserLogLevel } from '../../log';
+import type { IsoBaseMediaStructure } from '../../parse-result';
 import type { IsoBaseMediaSeekingHints } from '../../seeking-hints';
 import type { IsoBaseMediaState } from '../../state/iso-base-media/iso-state';
+import type { StructureState } from '../../state/structure';
 import type { SeekResolution } from '../../work-on-seek-request';
-export declare const getSeekingByteFromFragmentedMp4: ({ info, time, logLevel, currentPosition, isoState, allTracks, isLastChunkInPlaylist, }: {
+export declare const getSeekingByteFromFragmentedMp4: ({ info, time, logLevel, currentPosition, isoState, tracks, isLastChunkInPlaylist, structure, mp4HeaderSegment, }: {
     info: IsoBaseMediaSeekingHints;
     time: number;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     currentPosition: number;
     isoState: IsoBaseMediaState;
-    allTracks: (VideoTrack | AudioTrack | OtherTrack)[];
+    structure: StructureState;
+    tracks: MediaParserTrack[];
     isLastChunkInPlaylist: boolean;
+    mp4HeaderSegment: IsoBaseMediaStructure | null;
 }) => Promise<SeekResolution>;

package/dist/containers/iso-base-media/get-seeking-byte-from-fragmented-mp4.js

@@ -9,14 +9,27 @@ const find_keyframe_before_time_1 = require("./find-keyframe-before-time");
 const get_sample_position_bounds_1 = require("./get-sample-position-bounds");
 const find_best_segment_from_tfra_1 = require("./mfra/find-best-segment-from-tfra");
 const traversal_1 = require("./traversal");
-const getSeekingByteFromFragmentedMp4 = async ({ info, time, logLevel, currentPosition, isoState, allTracks, isLastChunkInPlaylist, }) => {
-    const firstVideoTrack = allTracks.find((t) => t.type === 'video');
+const getSeekingByteFromFragmentedMp4 = async ({ info, time, logLevel, currentPosition, isoState, tracks, isLastChunkInPlaylist, structure, mp4HeaderSegment, }) => {
+    const firstVideoTrack = tracks.find((t) => t.type === 'video');
     // If there is both video and audio, seek based on video, but if not then audio is also okay
-    const firstTrack = firstVideoTrack !== null && firstVideoTrack !== void 0 ? firstVideoTrack : allTracks.find((t) => t.type === 'audio');
+    const firstTrack = firstVideoTrack !== null && firstVideoTrack !== void 0 ? firstVideoTrack : tracks.find((t) => t.type === 'audio');
     if (!firstTrack) {
         throw new Error('no video and no audio tracks');
     }
-    const tkhdBox = (0, traversal_1.getTkhdBox)(firstTrack.trakBox);
+    const moov = (0, traversal_1.getMoovBoxFromState)({
+        structureState: structure,
+        isoState,
+        mp4HeaderSegment,
+        mayUsePrecomputed: true,
+    });
+    if (!moov) {
+        throw new Error('No moov atom found');
+    }
+    const trakBox = (0, traversal_1.getTrakBoxByTrackId)(moov, firstTrack.trackId);
+    if (!trakBox) {
+        throw new Error('No trak box found');
+    }
+    const tkhdBox = (0, traversal_1.getTkhdBox)(trakBox);
     if (!tkhdBox) {
         throw new Error('Expected tkhd box in trak box');
     }

package/dist/containers/iso-base-media/get-seeking-byte.d.ts

@@ -1,4 +1,4 @@
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } from '../../log';
 import type { M3uPlaylistContext } from '../../options';
 import type { IsoBaseMediaSeekingHints } from '../../seeking-hints';
 import type { IsoBaseMediaState } from '../../state/iso-base-media/iso-state';
@@ -7,7 +7,7 @@ import type { SeekResolution } from '../../work-on-seek-request';
 export declare const getSeekingByteFromIsoBaseMedia: ({ info, time, logLevel, currentPosition, isoState, m3uPlaylistContext, structure, }: {
     info: IsoBaseMediaSeekingHints;
     time: number;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     currentPosition: number;
     isoState: IsoBaseMediaState;
     m3uPlaylistContext: M3uPlaylistContext | null;

package/dist/containers/iso-base-media/get-seeking-byte.js

@@ -8,18 +8,13 @@ const find_track_to_seek_1 = require("./find-track-to-seek");
 const get_seeking_byte_from_fragmented_mp4_1 = require("./get-seeking-byte-from-fragmented-mp4");
 const traversal_1 = require("./traversal");
 const getSeekingByteFromIsoBaseMedia = ({ info, time, logLevel, currentPosition, isoState, m3uPlaylistContext, structure, }) => {
-    var _a, _b;
+    var _a, _b, _c;
     const tracks = (0, get_tracks_1.getTracksFromIsoBaseMedia)({
         isoState,
         m3uPlaylistContext,
         structure,
         mayUsePrecomputed: false,
     });
-    const allTracks = [
-        ...tracks.videoTracks,
-        ...tracks.audioTracks,
-        ...tracks.otherTracks,
-    ];
     const hasMoov = Boolean((0, traversal_1.getMoovBoxFromState)({
         structureState: structure,
         isoState,
@@ -39,11 +34,13 @@ const getSeekingByteFromIsoBaseMedia = ({ info, time, logLevel, currentPosition,
             logLevel,
             currentPosition,
             isoState,
-            allTracks,
+            tracks,
             isLastChunkInPlaylist: (_b = m3uPlaylistContext === null || m3uPlaylistContext === void 0 ? void 0 : m3uPlaylistContext.isLastChunkInPlaylist) !== null && _b !== void 0 ? _b : false,
+            structure,
+            mp4HeaderSegment: (_c = m3uPlaylistContext === null || m3uPlaylistContext === void 0 ? void 0 : m3uPlaylistContext.mp4HeaderSegment) !== null && _c !== void 0 ? _c : null,
         });
     }
-    const trackWithSamplePositions = (0, find_track_to_seek_1.findTrackToSeek)(allTracks, structure);
+    const trackWithSamplePositions = (0, find_track_to_seek_1.findTrackToSeek)(tracks, structure);
     if (!trackWithSamplePositions) {
         return Promise.resolve({
             type: 'valid-but-must-wait',

package/dist/containers/iso-base-media/make-track.d.ts

@@ -1,3 +1,3 @@
-import type { AudioTrack, OtherTrack, VideoTrack } from '../../get-tracks';
+import type { MediaParserAudioTrack, MediaParserOtherTrack, MediaParserVideoTrack } from '../../get-tracks';
 import type { TrakBox } from './trak/trak';
-export declare const makeBaseMediaTrack: (trakBox: TrakBox) => VideoTrack | AudioTrack | OtherTrack | null;
+export declare const makeBaseMediaTrack: (trakBox: TrakBox) => MediaParserVideoTrack | MediaParserAudioTrack | MediaParserOtherTrack | null;