@remotion/media-parser 4.0.298 → 4.0.301

package/dist/containers/iso-base-media/make-track.js

@@ -5,11 +5,12 @@ const get_audio_codec_1 = require("../../get-audio-codec");
 const get_fps_1 = require("../../get-fps");
 const get_sample_aspect_ratio_1 = require("../../get-sample-aspect-ratio");
 const get_video_codec_1 = require("../../get-video-codec");
+const color_to_webcodecs_colors_1 = require("./color-to-webcodecs-colors");
 const get_actual_number_of_channels_1 = require("./get-actual-number-of-channels");
 const get_video_codec_from_iso_track_1 = require("./get-video-codec-from-iso-track");
 const traversal_1 = require("./traversal");
 const makeBaseMediaTrack = (trakBox) => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     const tkhdBox = (0, traversal_1.getTkhdBox)(trakBox);
     const videoDescriptors = (0, traversal_1.getVideoDescriptors)(trakBox);
     const timescaleAndDuration = (0, get_fps_1.getTimescaleAndDuration)(trakBox);
@@ -30,10 +31,10 @@ const makeBaseMediaTrack = (trakBox) => {
         }
         const { codecString, description } = (0, get_audio_codec_1.getAudioCodecStringFromTrak)(trakBox);
         const codecPrivate = (_b = (_a = (0, get_audio_codec_1.getCodecPrivateFromTrak)(trakBox)) !== null && _a !== void 0 ? _a : description) !== null && _b !== void 0 ? _b : null;
-        const codecWithoutConfig = (0, get_audio_codec_1.getAudioCodecFromTrack)(trakBox);
+        const codecEnum = (0, get_audio_codec_1.getAudioCodecFromTrack)(trakBox);
         const actual = (0, get_actual_number_of_channels_1.getActualDecoderParameters)({
-            audioCodec: codecWithoutConfig,
-            codecPrivate,
+            audioCodec: codecEnum,
+            codecPrivate: codecPrivate !== null && codecPrivate !== void 0 ? codecPrivate : null,
             numberOfChannels,
             sampleRate,
         });
@@ -44,10 +45,9 @@ const makeBaseMediaTrack = (trakBox) => {
             codec: codecString,
             numberOfChannels: actual.numberOfChannels,
             sampleRate: actual.sampleRate,
-            description: (_c = actual.codecPrivate) !== null && _c !== void 0 ? _c : undefined,
-            trakBox,
-            codecPrivate: actual.codecPrivate,
-            codecWithoutConfig,
+            description: (_d = (_c = actual.codecPrivate) === null || _c === void 0 ? void 0 : _c.data) !== null && _d !== void 0 ? _d : undefined,
+            codecData: actual.codecPrivate,
+            codecEnum,
         };
     }
     if (!(0, get_fps_1.trakBoxContainsVideo)(trakBox)) {
@@ -77,6 +77,12 @@ const makeBaseMediaTrack = (trakBox) => {
         throw new Error('Could not find video codec');
     }
     const privateData = (0, get_video_codec_1.getVideoPrivateData)(trakBox);
+    const advancedColor = (_e = (0, get_video_codec_1.getIsoBmColrConfig)(trakBox)) !== null && _e !== void 0 ? _e : {
+        fullRange: null,
+        matrix: null,
+        primaries: null,
+        transfer: null,
+    };
     const track = {
         m3uStreamFormat: null,
         type: 'video',
@@ -93,15 +99,10 @@ const makeBaseMediaTrack = (trakBox) => {
         displayAspectWidth,
         displayAspectHeight,
         rotation,
-        trakBox,
-        codecPrivate: privateData,
-        color: (_d = (0, get_video_codec_1.getIsoBmColrConfig)(trakBox)) !== null && _d !== void 0 ? _d : {
-            fullRange: null,
-            matrixCoefficients: null,
-            primaries: null,
-            transferCharacteristics: null,
-        },
-        codecWithoutConfig: (0, get_video_codec_from_iso_track_1.getVideoCodecFromIsoTrak)(trakBox),
+        codecData: privateData,
+        colorSpace: (0, color_to_webcodecs_colors_1.mediaParserAdvancedColorToWebCodecsColor)(advancedColor),
+        advancedColor,
+        codecEnum: (0, get_video_codec_from_iso_track_1.getVideoCodecFromIsoTrak)(trakBox),
         fps: (0, get_fps_1.getFpsFromMp4TrakBox)(trakBox),
     };
     return track;

package/dist/containers/iso-base-media/mfra/find-best-segment-from-tfra.d.ts

@@ -1,9 +1,9 @@
-import type { AudioTrack, VideoTrack } from '../../../get-tracks';
+import type { MediaParserAudioTrack, MediaParserVideoTrack } from '../../../get-tracks';
 import type { IsoBaseMediaBox } from '../base-media-box';
 export declare const findBestSegmentFromTfra: ({ mfra, time, firstTrack, timescale, }: {
     mfra: IsoBaseMediaBox[];
     time: number;
-    firstTrack: VideoTrack | AudioTrack;
+    firstTrack: MediaParserVideoTrack | MediaParserAudioTrack;
     timescale: number;
 }) => {
     start: number;

package/dist/containers/iso-base-media/mfra/get-mfra-atom.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';
 export declare const getMfraAtom: ({ src, contentLength, readerInterface, controller, parentSize, logLevel, prefetchCache, }: {
     src: ParseMediaSrc;
     contentLength: number;
-    readerInterface: ReaderInterface;
+    readerInterface: MediaParserReaderInterface;
     controller: MediaParserController;
     parentSize: number;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     prefetchCache: PrefetchCache;
 }) => Promise<{
     startReadingBits: () => void;

package/dist/containers/iso-base-media/mfra/get-mfro-atom.d.ts

@@ -1,13 +1,13 @@
 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';
 export declare const getMfroAtom: ({ src, contentLength, readerInterface, controller, logLevel, prefetchCache, }: {
     src: ParseMediaSrc;
     contentLength: number;
-    readerInterface: ReaderInterface;
+    readerInterface: MediaParserReaderInterface;
     controller: MediaParserController;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     prefetchCache: PrefetchCache;
 }) => Promise<number | null>;

package/dist/containers/iso-base-media/moov/moov.d.ts

@@ -1,5 +1,5 @@
 import type { BufferIterator } from '../../../iterator/buffer-iterator';
-import type { LogLevel } from '../../../log';
+import type { MediaParserLogLevel } from '../../../log';
 import type { AnySegment } from '../../../parse-result';
 import type { BaseBox } from '../base-type';
 import type { OnlyIfMoovAtomExpected } from '../process-box';
@@ -12,6 +12,6 @@ export declare const parseMoov: ({ offset, size, onlyIfMoovAtomExpected, iterato
     size: number;
     onlyIfMoovAtomExpected: OnlyIfMoovAtomExpected;
     iterator: BufferIterator;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     contentLength: number;
 }) => Promise<MoovBox>;

package/dist/containers/iso-base-media/process-box.d.ts

@@ -1,17 +1,17 @@
 import type { BufferIterator } from '../../iterator/buffer-iterator';
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } from '../../log';
 import type { FetchMoreData } from '../../skip';
 import type { TracksState } from '../../state/has-tracks-section';
 import type { IsoBaseMediaState } from '../../state/iso-base-media/iso-state';
 import type { CallbacksState } from '../../state/sample-callbacks';
 import type { MediaSectionState } from '../../state/video-section';
-import type { OnAudioTrack, OnVideoTrack } from '../../webcodec-sample-types';
+import type { MediaParserOnAudioTrack, MediaParserOnVideoTrack } from '../../webcodec-sample-types';
 import type { IsoBaseMediaBox } from './base-media-box';
 export type OnlyIfMoovAtomExpected = {
     tracks: TracksState;
     isoState: IsoBaseMediaState | null;
-    onVideoTrack: OnVideoTrack | null;
-    onAudioTrack: OnAudioTrack | null;
+    onVideoTrack: MediaParserOnVideoTrack | null;
+    onAudioTrack: MediaParserOnAudioTrack | null;
     registerVideoSampleCallback: CallbacksState['registerVideoSampleCallback'];
     registerAudioSampleCallback: CallbacksState['registerAudioSampleCallback'];
 };
@@ -29,7 +29,7 @@ type ProcessBoxResult = {
 };
 export declare const processBox: ({ iterator, logLevel, onlyIfMoovAtomExpected, onlyIfMdatAtomExpected, contentLength, }: {
     iterator: BufferIterator;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     onlyIfMoovAtomExpected: OnlyIfMoovAtomExpected | null;
     onlyIfMdatAtomExpected: OnlyIfMdatAtomExpected | null;
     contentLength: number;

package/dist/containers/iso-base-media/stsd/mebx.d.ts

@@ -1,5 +1,5 @@
 import type { BufferIterator } from '../../../iterator/buffer-iterator';
-import type { LogLevel } from '../../../log';
+import type { MediaParserLogLevel } from '../../../log';
 import type { AnySegment } from '../../../parse-result';
 import type { BaseBox } from '../base-type';
 export interface MebxBox extends BaseBox {
@@ -12,6 +12,6 @@ export declare const parseMebx: ({ offset, size, iterator, logLevel, contentLeng
     offset: number;
     size: number;
     iterator: BufferIterator;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     contentLength: number;
 }) => Promise<MebxBox>;

package/dist/containers/iso-base-media/stsd/samples.d.ts

@@ -1,5 +1,5 @@
 import type { BufferIterator } from '../../../iterator/buffer-iterator';
-import type { LogLevel } from '../../../log';
+import type { MediaParserLogLevel } from '../../../log';
 import type { AnySegment } from '../../../parse-result';
 import type { IsoBaseMediaBox } from '../base-media-box';
 type SampleBase = {
@@ -51,12 +51,12 @@ type FormatBoxAndNext = {
 };
 export declare const processIsoFormatBox: ({ iterator, logLevel, contentLength, }: {
     iterator: BufferIterator;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     contentLength: number;
 }) => Promise<FormatBoxAndNext>;
 export declare const parseIsoFormatBoxes: ({ maxBytes, logLevel, iterator, contentLength, }: {
     maxBytes: number;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     iterator: BufferIterator;
     contentLength: number;
 }) => Promise<Sample[]>;

package/dist/containers/iso-base-media/stsd/stsd.d.ts

@@ -1,5 +1,5 @@
 import type { BufferIterator } from '../../../iterator/buffer-iterator';
-import type { LogLevel } from '../../../log';
+import type { MediaParserLogLevel } from '../../../log';
 import type { BaseBox } from '../base-type';
 import type { Sample } from './samples';
 export interface StsdBox extends BaseBox {
@@ -11,6 +11,6 @@ export declare const parseStsd: ({ offset, size, iterator, logLevel, contentLeng
     offset: number;
     size: number;
     iterator: BufferIterator;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     contentLength: number;
 }) => Promise<StsdBox>;

package/dist/containers/iso-base-media/trak/trak.d.ts

@@ -1,5 +1,5 @@
 import type { BufferIterator } from '../../../iterator/buffer-iterator';
-import type { LogLevel } from '../../../log';
+import type { MediaParserLogLevel } from '../../../log';
 import type { AnySegment } from '../../../parse-result';
 import type { BaseBox } from '../base-type';
 export interface TrakBox extends BaseBox {
@@ -10,6 +10,6 @@ export declare const parseTrak: ({ size, offsetAtStart, iterator, logLevel, cont
     size: number;
     offsetAtStart: number;
     iterator: BufferIterator;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     contentLength: number;
 }) => Promise<TrakBox>;

package/dist/containers/iso-base-media/traversal.d.ts

@@ -48,3 +48,4 @@ export declare const getTfhdBox: (segment: IsoBaseMediaBox) => TfhdBox | null;
 export declare const getTrunBoxes: (segment: IsoBaseMediaBox) => TrunBox[];
 export declare const getTfraBoxesFromMfraBoxChildren: (mfraBoxChildren: IsoBaseMediaBox[]) => TfraBox[];
 export declare const getTfraBoxes: (structure: IsoBaseMediaBox[]) => TfraBox[];
+export declare const getTrakBoxByTrackId: (moovBox: MoovBox, trackId: number) => TrakBox | null;

package/dist/containers/iso-base-media/traversal.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTfraBoxes = exports.getTfraBoxesFromMfraBoxChildren = exports.getTrunBoxes = exports.getTfhdBox = exports.getTfdtBox = exports.getStssBox = exports.getStscBox = exports.getStszBox = exports.getCttsBox = exports.getSttsBox = exports.getStcoBox = exports.getVideoDescriptors = exports.getStsdBox = exports.getStblBox = exports.getMdhdBox = exports.getMdiaBox = exports.getTkhdBox = exports.getTraks = exports.getMvhdBox = exports.getMoofBoxes = exports.getMoovBoxFromState = exports.getMoovFromFromIsoStructure = exports.getFtypBox = void 0;
+exports.getTrakBoxByTrackId = exports.getTfraBoxes = exports.getTfraBoxesFromMfraBoxChildren = exports.getTrunBoxes = exports.getTfhdBox = exports.getTfdtBox = exports.getStssBox = exports.getStscBox = exports.getStszBox = exports.getCttsBox = exports.getSttsBox = exports.getStcoBox = exports.getVideoDescriptors = exports.getStsdBox = exports.getStblBox = exports.getMdhdBox = exports.getMdiaBox = exports.getTkhdBox = exports.getTraks = exports.getMvhdBox = exports.getMoofBoxes = exports.getMoovBoxFromState = exports.getMoovFromFromIsoStructure = exports.getFtypBox = void 0;
 const precomputed_moof_1 = require("../../state/iso-base-media/precomputed-moof");
 const getFtypBox = (segments) => {
     const ftypBox = segments.find((s) => s.type === 'ftyp-box');
@@ -211,3 +211,15 @@ const getTfraBoxes = (structure) => {
     return (0, exports.getTfraBoxesFromMfraBoxChildren)(mfraBox.children);
 };
 exports.getTfraBoxes = getTfraBoxes;
+const getTrakBoxByTrackId = (moovBox, trackId) => {
+    var _a;
+    const trakBoxes = (0, exports.getTraks)(moovBox);
+    return ((_a = trakBoxes.find((t) => {
+        const tkhd = (0, exports.getTkhdBox)(t);
+        if (!tkhd) {
+            return false;
+        }
+        return tkhd.trackId === trackId;
+    })) !== null && _a !== void 0 ? _a : null);
+};
+exports.getTrakBoxByTrackId = getTrakBoxByTrackId;

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

@@ -1,8 +1,8 @@
-import type { LogLevel } from '../../log';
-import type { ReaderInterface } from '../../readers/reader';
+import type { MediaParserLogLevel } from '../../log';
+import type { MediaParserReaderInterface } 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 { MediaParserOnAudioTrack } 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, onAudioTrack, canSkipTracks, }: {
@@ -11,8 +11,8 @@ export declare const afterManifestFetch: ({ structure, m3uState, src, selectM3uS
     src: string;
     selectM3uStreamFn: SelectM3uStreamFn;
     selectAssociatedPlaylistsFn: SelectM3uAssociatedPlaylistsFn;
-    logLevel: LogLevel;
-    readerInterface: ReaderInterface;
-    onAudioTrack: OnAudioTrack | null;
+    logLevel: MediaParserLogLevel;
+    readerInterface: MediaParserReaderInterface;
+    onAudioTrack: MediaParserOnAudioTrack | null;
     canSkipTracks: CanSkipTracksState;
 }) => Promise<void>;

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

@@ -22,7 +22,7 @@ const afterManifestFetch = async ({ structure, m3uState, src, selectM3uStreamFn,
         throw new Error('No streams found');
     }
     const selectedPlaylist = await (0, select_stream_1.selectStream)({ streams, fn: selectM3uStreamFn });
-    if (!selectedPlaylist.resolution) {
+    if (!selectedPlaylist.dimensions) {
         throw new Error('Stream does not have a resolution');
     }
     m3uState.setSelectedMainPlaylist({

package/dist/containers/m3u/fetch-m3u8-stream.d.ts

@@ -1,6 +1,6 @@
-import type { ReaderInterface } from '../../readers/reader';
+import type { MediaParserReaderInterface } from '../../readers/reader';
 import type { M3uBox } from './types';
 export declare const fetchM3u8Stream: ({ url, readerInterface, }: {
     url: string;
-    readerInterface: ReaderInterface;
+    readerInterface: MediaParserReaderInterface;
 }) => Promise<M3uBox[]>;

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

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

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

@@ -14,17 +14,11 @@ const considerSeekBasedOnChunk = async ({ sample, parentController, childControl
         chunkIndex !== null &&
         chunkIndex > 0) {
         m3uState.setNextSeekShouldSubtractChunks(playlistUrl, subtractChunks + 1);
-        parentController.seek({
-            type: 'keyframe-before-time',
-            timeInSeconds: pendingSeek.targetTime,
-        });
+        parentController.seek(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,
-    });
+    childController.seek(pendingSeek.targetTime);
     m3uState.setNextSeekShouldSubtractChunks(playlistUrl, 0);
     m3uState.setSeekToSecondsToProcess(playlistUrl, null);
 };

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

@@ -1,13 +1,13 @@
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } 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;
+    logLevel: MediaParserLogLevel;
 }) => void;
 export declare const getSeekingByteForM3u8: ({ time, currentPosition, m3uState, logLevel, }: {
     time: number;
     currentPosition: number;
     m3uState: M3uState;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
 }) => SeekResolution;

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

@@ -1,7 +1,7 @@
-import type { Dimensions } from '../../get-dimensions';
+import type { MediaParserDimensions } from '../../get-dimensions';
 import type { ParseMediaSrc } from '../../options';
 import type { MediaParserStructureUnstable } from '../../parse-result';
-import type { ReaderInterface } from '../../readers/reader';
+import type { MediaParserReaderInterface } from '../../readers/reader';
 import type { ParserState } from '../../state/parser-state';
 export type M3uAssociatedPlaylist = {
     groupId: string;
@@ -16,9 +16,9 @@ export type M3uAssociatedPlaylist = {
 };
 export type M3uStream = {
     src: string;
-    bandwidth: number | null;
-    averageBandwidth: number | null;
-    resolution: Dimensions | null;
+    bandwidthInBitsPerSec: number | null;
+    averageBandwidthInBitsPerSec: number | null;
+    dimensions: MediaParserDimensions | null;
     codecs: string[] | null;
     id: number;
     associatedPlaylists: M3uAssociatedPlaylist[];
@@ -27,6 +27,6 @@ export declare const isIndependentSegments: (structure: MediaParserStructureUnst
 export declare const getM3uStreams: ({ structure, originalSrc, readerInterface, }: {
     structure: MediaParserStructureUnstable | null;
     originalSrc: ParseMediaSrc;
-    readerInterface: ReaderInterface;
+    readerInterface: MediaParserReaderInterface;
 }) => M3uStream[] | null;
 export declare const m3uHasStreams: (state: ParserState) => boolean;

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

@@ -41,10 +41,10 @@ const getM3uStreams = ({ structure, originalSrc, readerInterface, }) => {
             }
             boxes.push({
                 src: readerInterface.createAdjacentFileSource(next.value, originalSrc),
-                averageBandwidth: str.averageBandwidth,
-                bandwidth: str.bandwidth,
+                averageBandwidthInBitsPerSec: str.averageBandwidthInBitsPerSec,
+                bandwidthInBitsPerSec: str.bandwidthInBitsPerSec,
                 codecs: str.codecs,
-                resolution: str.resolution,
+                dimensions: str.dimensions,
                 associatedPlaylists,
             });
         }
@@ -55,15 +55,15 @@ const getM3uStreams = ({ structure, originalSrc, readerInterface, }) => {
     }
     const sorted = boxes.slice().sort((a, b) => {
         var _a, _b, _c, _d;
-        const aResolution = a.resolution
-            ? a.resolution.width * a.resolution.height
+        const aResolution = a.dimensions
+            ? a.dimensions.width * a.dimensions.height
             : 0;
-        const bResolution = b.resolution
-            ? b.resolution.width * b.resolution.height
+        const bResolution = b.dimensions
+            ? b.dimensions.width * b.dimensions.height
             : 0;
         if (aResolution === bResolution) {
-            const bandwidthA = (_b = (_a = a.averageBandwidth) !== null && _a !== void 0 ? _a : a.bandwidth) !== null && _b !== void 0 ? _b : 0;
-            const bandwidthB = (_d = (_c = b.averageBandwidth) !== null && _c !== void 0 ? _c : b.bandwidth) !== null && _d !== void 0 ? _d : 0;
+            const bandwidthA = (_b = (_a = a.averageBandwidthInBitsPerSec) !== null && _a !== void 0 ? _a : a.bandwidthInBitsPerSec) !== null && _b !== void 0 ? _b : 0;
+            const bandwidthB = (_d = (_c = b.averageBandwidthInBitsPerSec) !== null && _c !== void 0 ? _c : b.bandwidthInBitsPerSec) !== null && _d !== void 0 ? _d : 0;
             return bandwidthB - bandwidthA;
         }
         return bResolution - aResolution;

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

@@ -45,12 +45,12 @@ const parseStreamInf = (str) => {
     }
     return {
         type: 'm3u-stream-info',
-        averageBandwidth: map['AVERAGE-BANDWIDTH']
+        averageBandwidthInBitsPerSec: map['AVERAGE-BANDWIDTH']
             ? parseInt(map['AVERAGE-BANDWIDTH'], 10)
             : null,
-        bandwidth: map.BANDWIDTH ? parseInt(map.BANDWIDTH, 10) : null,
+        bandwidthInBitsPerSec: map.BANDWIDTH ? parseInt(map.BANDWIDTH, 10) : null,
         codecs: map.CODECS ? map.CODECS.split(',') : null,
-        resolution: map.RESOLUTION
+        dimensions: map.RESOLUTION
             ? {
                 width: parseInt(map.RESOLUTION.split('x')[0], 10),
                 height: parseInt(map.RESOLUTION.split('x')[1], 10),

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

@@ -145,7 +145,7 @@ const processM3uChunk = ({ playlistUrl, state, structure, audioDone, videoDone,
                         childController.pause();
                         currentPromise.resolver(makeContinuationFn());
                     },
-                    fields: chunk.isHeader ? { structure: true } : undefined,
+                    fields: chunk.isHeader ? { slowStructure: true } : undefined,
                     onTracks: () => {
                         if (!state.m3u.hasEmittedDoneWithTracks(playlistUrl)) {
                             state.m3u.setHasEmittedDoneWithTracks(playlistUrl);
@@ -247,10 +247,10 @@ const processM3uChunk = ({ playlistUrl, state, structure, audioDone, videoDone,
                     },
                 });
                 if (chunk.isHeader) {
-                    if (data.structure.type !== 'iso-base-media') {
+                    if (data.slowStructure.type !== 'iso-base-media') {
                         throw new Error('Expected an mp4 file');
                     }
-                    state.m3u.setMp4HeaderSegment(playlistUrl, data.structure);
+                    state.m3u.setMp4HeaderSegment(playlistUrl, data.slowStructure);
                 }
             }
             catch (e) {

package/dist/containers/m3u/run-over-m3u.d.ts

@@ -1,9 +1,9 @@
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } from '../../log';
 import type { ParserState } from '../../state/parser-state';
 import type { M3uStructure } from './types';
 export declare const runOverM3u: ({ state, structure, playlistUrl, logLevel, }: {
     state: ParserState;
     structure: M3uStructure;
     playlistUrl: string;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
 }) => Promise<void>;

package/dist/containers/m3u/sample-sorter.d.ts

@@ -1,16 +1,16 @@
-import type { LogLevel } from '../../log';
-import type { AudioOrVideoSample, OnAudioSample, OnVideoSample } from '../../webcodec-sample-types';
+import type { MediaParserLogLevel } from '../../log';
+import type { MediaParserAudioSample, MediaParserOnAudioSample, MediaParserOnVideoSample, MediaParserVideoSample } from '../../webcodec-sample-types';
 export declare const sampleSorter: ({ logLevel, getAllChunksProcessedForPlaylist, }: {
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     getAllChunksProcessedForPlaylist: (src: string) => boolean;
 }) => {
     clearSamples: () => void;
     addToStreamWithTrack: (src: string) => void;
-    addVideoStreamToConsider: (src: string, callback: OnVideoSample) => void;
-    addAudioStreamToConsider: (src: string, callback: OnAudioSample) => void;
+    addVideoStreamToConsider: (src: string, callback: MediaParserOnVideoSample) => void;
+    addAudioStreamToConsider: (src: string, callback: MediaParserOnAudioSample) => void;
     hasAudioStreamToConsider: (src: string) => boolean;
     hasVideoStreamToConsider: (src: string) => boolean;
-    addAudioSample: (src: string, sample: AudioOrVideoSample) => Promise<void>;
-    addVideoSample: (src: string, sample: AudioOrVideoSample) => Promise<void>;
+    addAudioSample: (src: string, sample: MediaParserAudioSample) => Promise<void>;
+    addVideoSample: (src: string, sample: MediaParserVideoSample) => Promise<void>;
     getNextStreamToRun: (streams: string[]) => string;
 };

package/dist/containers/m3u/types.d.ts

@@ -49,10 +49,10 @@ export type M3uMap = {
 };
 export type M3uStreamInfo = {
     type: 'm3u-stream-info';
-    bandwidth: number | null;
-    averageBandwidth: number | null;
+    bandwidthInBitsPerSec: number | null;
+    averageBandwidthInBitsPerSec: number | null;
     codecs: string[] | null;
-    resolution: {
+    dimensions: {
         width: number;
         height: number;
     } | null;

package/dist/containers/mp3/parse-mpeg-header.js

@@ -60,14 +60,13 @@ const parseMpegHeader = async ({ state, }) => {
             track: {
                 type: 'audio',
                 codec: 'mp3',
-                codecPrivate: null,
-                codecWithoutConfig: 'mp3',
+                codecData: null,
+                codecEnum: 'mp3',
                 description: undefined,
                 numberOfChannels,
                 sampleRate,
                 timescale: 1000000,
                 trackId: 0,
-                trakBox: null,
             },
             registerAudioSampleCallback: state.callbacks.registerAudioSampleCallback,
             tracks: state.callbacks.tracks,

package/dist/containers/mp3/seek/audio-sample-from-cbr.d.ts

@@ -1,5 +1,5 @@
 import type { ParserState } from '../../../state/parser-state';
-import type { AudioOrVideoSample } from '../../../webcodec-sample-types';
+import type { MediaParserAudioSample } from '../../../webcodec-sample-types';
 export declare const getAudioSampleFromCbr: ({ bitrateInKbit, initialOffset, layer, sampleRate, samplesPerFrame, data, state, }: {
     bitrateInKbit: number;
     layer: number;
@@ -9,7 +9,7 @@ export declare const getAudioSampleFromCbr: ({ bitrateInKbit, initialOffset, lay
     data: Uint8Array;
     state: ParserState;
 }) => {
-    audioSample: AudioOrVideoSample;
+    audioSample: MediaParserAudioSample;
     timeInSeconds: number;
     durationInSeconds: number;
 };

package/dist/containers/riff/get-tracks-from-avi.d.ts

@@ -1,21 +1,16 @@
-import type { AudioTrack, OtherTrack, VideoTrack } from '../../get-tracks';
+import type { MediaParserAudioTrack, MediaParserTrack, MediaParserVideoTrack } from '../../get-tracks';
 import type { ParserState } from '../../state/parser-state';
 import type { RiffStructure, StrfBoxAudio, StrfBoxVideo, StrhBox } from './riff-box';
-export type AllTracks = {
-    videoTracks: VideoTrack[];
-    audioTracks: AudioTrack[];
-    otherTracks: OtherTrack[];
-};
 export declare const TO_BE_OVERRIDDEN_LATER = "to-be-overriden-later";
 export declare const getNumberOfTracks: (structure: RiffStructure) => number;
 export declare const makeAviAudioTrack: ({ strf, index, }: {
     strf: StrfBoxAudio;
     index: number;
-}) => AudioTrack;
+}) => MediaParserAudioTrack;
 export declare const makeAviVideoTrack: ({ strh, strf, index, }: {
     strh: StrhBox;
     strf: StrfBoxVideo;
     index: number;
-}) => VideoTrack;
-export declare const getTracksFromAvi: (structure: RiffStructure, state: ParserState) => AllTracks;
+}) => MediaParserVideoTrack;
+export declare const getTracksFromAvi: (structure: RiffStructure, state: ParserState) => MediaParserTrack[];
 export declare const hasAllTracksFromAvi: (state: ParserState) => boolean;