@remotion/media-parser 4.0.298 → 4.0.300

package/dist/containers/riff/get-tracks-from-avi.js

@@ -21,14 +21,13 @@ const makeAviAudioTrack = ({ strf, index, }) => {
     return {
         type: 'audio',
         codec: 'mp4a.40.2', // According to Claude 3.5 Sonnet
-        codecPrivate: new Uint8Array([18, 16]),
-        codecWithoutConfig: 'aac',
+        codecData: { type: 'aac-config', data: new Uint8Array([18, 16]) },
+        codecEnum: 'aac',
         description: new Uint8Array([18, 16]),
         numberOfChannels: strf.numberOfChannels,
         sampleRate: strf.sampleRate,
         timescale: timescale_1.MEDIA_PARSER_RIFF_TIMESCALE,
         trackId: index,
-        trakBox: null,
     };
 };
 exports.makeAviAudioTrack = makeAviAudioTrack;
@@ -37,9 +36,9 @@ const makeAviVideoTrack = ({ strh, strf, index, }) => {
         throw new Error(`Unsupported video codec ${strh.handler}`);
     }
     return {
-        codecPrivate: null,
+        codecData: null,
         codec: exports.TO_BE_OVERRIDDEN_LATER,
-        codecWithoutConfig: 'h264',
+        codecEnum: 'h264',
         codedHeight: strf.height,
         codedWidth: strf.width,
         width: strf.width,
@@ -50,14 +49,19 @@ const makeAviVideoTrack = ({ strh, strf, index, }) => {
         description: undefined,
         m3uStreamFormat: null,
         trackId: index,
-        color: {
+        colorSpace: {
             fullRange: null,
-            matrixCoefficients: null,
+            matrix: null,
             primaries: null,
-            transferCharacteristics: null,
+            transfer: null,
+        },
+        advancedColor: {
+            fullRange: null,
+            matrix: null,
+            primaries: null,
+            transfer: null,
         },
         displayAspectWidth: strf.width,
-        trakBox: null,
         rotation: 0,
         sampleAspectRatio: {
             numerator: 1,
@@ -68,9 +72,7 @@ const makeAviVideoTrack = ({ strh, strf, index, }) => {
 };
 exports.makeAviVideoTrack = makeAviVideoTrack;
 const getTracksFromAvi = (structure, state) => {
-    const videoTracks = [];
-    const audioTracks = [];
-    const otherTracks = [];
+    const tracks = [];
     const boxes = (0, traversal_1.getStrlBoxes)(structure);
     let i = 0;
     for (const box of boxes) {
@@ -80,17 +82,17 @@ const getTracksFromAvi = (structure, state) => {
         }
         const { strf } = strh;
         if (strf.type === 'strf-box-video') {
-            videoTracks.push((0, add_avc_profile_to_track_1.addAvcProfileToTrack)((0, exports.makeAviVideoTrack)({ strh, strf, index: i }), state.riff.getAvcProfile()));
+            tracks.push((0, add_avc_profile_to_track_1.addAvcProfileToTrack)((0, exports.makeAviVideoTrack)({ strh, strf, index: i }), state.riff.getAvcProfile()));
         }
         else if (strh.fccType === 'auds') {
-            audioTracks.push((0, exports.makeAviAudioTrack)({ strf, index: i }));
+            tracks.push((0, exports.makeAviAudioTrack)({ strf, index: i }));
         }
         else {
             throw new Error(`Unsupported track type ${strh.fccType}`);
         }
         i++;
     }
-    return { audioTracks, otherTracks, videoTracks };
+    return tracks;
 };
 exports.getTracksFromAvi = getTracksFromAvi;
 const hasAllTracksFromAvi = (state) => {
@@ -98,11 +100,8 @@ const hasAllTracksFromAvi = (state) => {
         const structure = state.structure.getRiffStructure();
         const numberOfTracks = (0, exports.getNumberOfTracks)(structure);
         const tracks = (0, exports.getTracksFromAvi)(structure, state);
-        return (tracks.videoTracks.length +
-            tracks.audioTracks.length +
-            tracks.otherTracks.length ===
-            numberOfTracks &&
-            !tracks.videoTracks.find((t) => t.codec === exports.TO_BE_OVERRIDDEN_LATER));
+        return (tracks.length === numberOfTracks &&
+            !tracks.find((t) => t.type === 'video' && t.codec === exports.TO_BE_OVERRIDDEN_LATER));
     }
     catch (_a) {
         return false;

package/dist/containers/riff/parse-video-section.js

@@ -9,7 +9,7 @@ const parseMediaSection = async (state) => {
         state,
     });
     const tracks = (0, get_tracks_1.getTracks)(state, false);
-    if (!tracks.videoTracks.some((t) => t.codec === get_tracks_from_avi_1.TO_BE_OVERRIDDEN_LATER) &&
+    if (!tracks.some((t) => t.type === 'video' && t.codec === get_tracks_from_avi_1.TO_BE_OVERRIDDEN_LATER) &&
         !state.callbacks.tracks.getIsDone()) {
         state.callbacks.tracks.setIsDone(state.logLevel);
     }

package/dist/containers/riff/seek/fetch-idx1.d.ts

@@ -1,14 +1,14 @@
 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 fetchIdx1: ({ src, readerInterface, controller, position, logLevel, prefetchCache, }: {
     src: ParseMediaSrc;
-    readerInterface: ReaderInterface;
+    readerInterface: MediaParserReaderInterface;
     controller: MediaParserController;
     position: number;
-    logLevel: LogLevel;
+    logLevel: MediaParserLogLevel;
     prefetchCache: PrefetchCache;
 }) => Promise<{
     entries: import("../riff-box").Idx1Entry[];

package/dist/containers/transport-stream/get-tracks.d.ts

@@ -1,6 +1,6 @@
+import type { MediaParserTrack } from '../../get-tracks';
 import type { ParserState } from '../../state/parser-state';
-import type { AllTracks } from '../riff/get-tracks-from-avi';
 import type { TransportStreamEntry } from './parse-pmt';
 export declare const filterStreamsBySupportedTypes: (streams: TransportStreamEntry[]) => TransportStreamEntry[];
-export declare const getTracksFromTransportStream: (parserState: ParserState) => AllTracks;
+export declare const getTracksFromTransportStream: (parserState: ParserState) => MediaParserTrack[];
 export declare const hasAllTracksFromTransportStream: (parserState: ParserState) => boolean;

package/dist/containers/transport-stream/get-tracks.js

@@ -20,11 +20,7 @@ const getTracksFromTransportStream = (parserState) => {
         (0, exports.filterStreamsBySupportedTypes)(programMapTable.streams).length) {
         throw new Error('Not all tracks found');
     }
-    return {
-        videoTracks: mapped.filter((track) => track.type === 'video'),
-        audioTracks: mapped.filter((track) => track.type === 'audio'),
-        otherTracks: [],
-    };
+    return mapped;
 };
 exports.getTracksFromTransportStream = getTracksFromTransportStream;
 const hasAllTracksFromTransportStream = (parserState) => {

package/dist/containers/transport-stream/handle-aac-packet.d.ts

@@ -1,15 +1,15 @@
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } from '../../log';
 import type { CallbacksState } from '../../state/sample-callbacks';
 import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
-import type { OnAudioTrack } from '../../webcodec-sample-types';
+import type { MediaParserOnAudioTrack } from '../../webcodec-sample-types';
 import type { TransportStreamPacketBuffer } from './process-stream-buffers';
 export declare const handleAacPacket: ({ streamBuffer, programId, offset, sampleCallbacks, logLevel, onAudioTrack, transportStream, makeSamplesStartAtZero, }: {
     streamBuffer: TransportStreamPacketBuffer;
     programId: number;
     offset: number;
     sampleCallbacks: CallbacksState;
-    logLevel: LogLevel;
-    onAudioTrack: OnAudioTrack | null;
+    logLevel: MediaParserLogLevel;
+    onAudioTrack: MediaParserOnAudioTrack | null;
     transportStream: TransportStreamState;
     makeSamplesStartAtZero: boolean;
 }) => Promise<void>;

package/dist/containers/transport-stream/handle-aac-packet.js

@@ -26,14 +26,15 @@ const handleAacPacket = async ({ streamBuffer, programId, offset, sampleCallback
         });
         const track = {
             type: 'audio',
-            codecPrivate,
+            codecData: { type: 'aac-config', data: codecPrivate },
             trackId: programId,
-            trakBox: null,
             timescale: handle_avc_packet_1.MPEG_TIMESCALE,
-            codecWithoutConfig: 'aac',
+            codecEnum: 'aac',
             codec: (0, aac_codecprivate_1.mapAudioObjectTypeToCodecString)(audioObjectType),
             // https://www.w3.org/TR/webcodecs-aac-codec-registration/
-            description: undefined,
+            // WebCodecs spec says that description should be given for AAC format
+            // ChatGPT says that Transport Streams are always AAC, not ADTS
+            description: codecPrivate,
             numberOfChannels: channelConfiguration,
             sampleRate,
         };

package/dist/containers/transport-stream/handle-avc-packet.d.ts

@@ -1,7 +1,7 @@
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } from '../../log';
 import type { CallbacksState } from '../../state/sample-callbacks';
 import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
-import type { OnVideoTrack } from '../../webcodec-sample-types';
+import type { MediaParserOnVideoTrack } from '../../webcodec-sample-types';
 import type { TransportStreamPacketBuffer } from './process-stream-buffers';
 export declare const MPEG_TIMESCALE = 90000;
 export declare const handleAvcPacket: ({ streamBuffer, programId, offset, sampleCallbacks, logLevel, onVideoTrack, transportStream, makeSamplesStartAtZero, }: {
@@ -9,8 +9,8 @@ export declare const handleAvcPacket: ({ streamBuffer, programId, offset, sample
     programId: number;
     offset: number;
     sampleCallbacks: CallbacksState;
-    logLevel: LogLevel;
-    onVideoTrack: OnVideoTrack | null;
+    logLevel: MediaParserLogLevel;
+    onVideoTrack: MediaParserOnVideoTrack | null;
     transportStream: TransportStreamState;
     makeSamplesStartAtZero: boolean;
 }) => Promise<void>;

package/dist/containers/transport-stream/handle-avc-packet.js

@@ -9,6 +9,7 @@ const interpret_sps_1 = require("../avc/interpret-sps");
 const key_1 = require("../avc/key");
 const parse_avc_1 = require("../avc/parse-avc");
 const sps_and_pps_1 = require("../avc/sps-and-pps");
+const color_to_webcodecs_colors_1 = require("../iso-base-media/color-to-webcodecs-colors");
 exports.MPEG_TIMESCALE = 90000;
 const handleAvcPacket = async ({ streamBuffer, programId, offset, sampleCallbacks, logLevel, onVideoTrack, transportStream, makeSamplesStartAtZero, }) => {
     var _a, _b;
@@ -27,6 +28,8 @@ const handleAvcPacket = async ({ streamBuffer, programId, offset, sampleCallback
             trackId: programId,
             newOffset: startOffset,
         });
+        const codecPrivate = (0, create_sps_pps_data_1.createSpsPpsData)(spsAndPps);
+        const advancedColor = (0, interpret_sps_1.getVideoColorFromSps)(spsAndPps.sps.spsData);
         const track = {
             m3uStreamFormat: null,
             rotation: 0,
@@ -34,7 +37,7 @@ const handleAvcPacket = async ({ streamBuffer, programId, offset, sampleCallback
             type: 'video',
             timescale: exports.MPEG_TIMESCALE,
             codec: (0, codec_string_1.getCodecStringFromSpsAndPps)(spsAndPps.sps),
-            codecPrivate: (0, create_sps_pps_data_1.createSpsPpsData)(spsAndPps),
+            codecData: { type: 'avc-sps-pps', data: codecPrivate },
             fps: null,
             codedWidth: dimensions.width,
             codedHeight: dimensions.height,
@@ -42,14 +45,17 @@ const handleAvcPacket = async ({ streamBuffer, programId, offset, sampleCallback
             width: dimensions.width,
             displayAspectWidth: dimensions.width,
             displayAspectHeight: dimensions.height,
-            trakBox: null,
-            codecWithoutConfig: 'h264',
+            codecEnum: 'h264',
+            // ChatGPT: In a transport stream (⁠.ts), H.264 video is always stored in Annex B format
+            // WebCodecs spec says that description must be undefined for Annex B format
+            // https://www.w3.org/TR/webcodecs-avc-codec-registration/#videodecoderconfig-description
             description: undefined,
             sampleAspectRatio: {
                 denominator: sampleAspectRatio.height,
                 numerator: sampleAspectRatio.width,
             },
-            color: (0, interpret_sps_1.getVideoColorFromSps)(spsAndPps.sps.spsData),
+            colorSpace: (0, color_to_webcodecs_colors_1.mediaParserAdvancedColorToWebCodecsColor)(advancedColor),
+            advancedColor,
         };
         await (0, register_track_1.registerVideoTrack)({
             track,

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

@@ -1,8 +1,8 @@
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } from '../../log';
 import type { TransportStreamStructure } from '../../parse-result';
 import type { CallbacksState } from '../../state/sample-callbacks';
 import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
-import type { OnAudioTrack, OnVideoTrack } from '../../webcodec-sample-types';
+import type { MediaParserOnAudioTrack, MediaParserOnVideoTrack } from '../../webcodec-sample-types';
 import type { TransportStreamEntry } from './parse-pmt';
 import type { TransportStreamPacketBuffer } from './process-stream-buffers';
 export declare const canProcessAudio: ({ streamBuffer, }: {
@@ -12,9 +12,9 @@ export declare const processAudio: ({ transportStreamEntry, structure, offset, s
     transportStreamEntry: TransportStreamEntry;
     structure: TransportStreamStructure;
     sampleCallbacks: CallbacksState;
-    logLevel: LogLevel;
-    onAudioTrack: OnAudioTrack | null;
-    onVideoTrack: OnVideoTrack | null;
+    logLevel: MediaParserLogLevel;
+    onAudioTrack: MediaParserOnAudioTrack | null;
+    onVideoTrack: MediaParserOnVideoTrack | null;
     transportStream: TransportStreamState;
     offset: number;
     makeSamplesStartAtZero: boolean;

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

@@ -1,8 +1,8 @@
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } from '../../log';
 import type { TransportStreamStructure } from '../../parse-result';
 import type { CallbacksState } from '../../state/sample-callbacks';
 import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
-import type { OnAudioTrack, OnVideoTrack } from '../../webcodec-sample-types';
+import type { MediaParserOnAudioTrack, MediaParserOnVideoTrack } from '../../webcodec-sample-types';
 import type { PacketPes } from './parse-pes';
 export type TransportStreamPacketBuffer = {
     pesHeader: PacketPes;
@@ -22,18 +22,18 @@ export declare const processStreamBuffer: ({ streamBuffer, programId, structure,
     programId: number;
     structure: TransportStreamStructure;
     sampleCallbacks: CallbacksState;
-    logLevel: LogLevel;
-    onAudioTrack: OnAudioTrack | null;
-    onVideoTrack: OnVideoTrack | null;
+    logLevel: MediaParserLogLevel;
+    onAudioTrack: MediaParserOnAudioTrack | null;
+    onVideoTrack: MediaParserOnVideoTrack | null;
     transportStream: TransportStreamState;
     makeSamplesStartAtZero: boolean;
 }) => Promise<void>;
 export declare const processFinalStreamBuffers: ({ structure, sampleCallbacks, logLevel, onAudioTrack, onVideoTrack, transportStream, makeSamplesStartAtZero, }: {
     structure: TransportStreamStructure;
     sampleCallbacks: CallbacksState;
-    logLevel: LogLevel;
-    onAudioTrack: OnAudioTrack | null;
-    onVideoTrack: OnVideoTrack | null;
+    logLevel: MediaParserLogLevel;
+    onAudioTrack: MediaParserOnAudioTrack | null;
+    onVideoTrack: MediaParserOnVideoTrack | null;
     transportStream: TransportStreamState;
     makeSamplesStartAtZero: boolean;
 }) => Promise<void>;

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

@@ -1,8 +1,8 @@
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } from '../../log';
 import type { TransportStreamStructure } from '../../parse-result';
 import type { CallbacksState } from '../../state/sample-callbacks';
 import type { TransportStreamState } from '../../state/transport-stream/transport-stream';
-import type { OnAudioTrack, OnVideoTrack } from '../../webcodec-sample-types';
+import type { MediaParserOnAudioTrack, MediaParserOnVideoTrack } from '../../webcodec-sample-types';
 import type { TransportStreamPacketBuffer } from './process-stream-buffers';
 export declare const canProcessVideo: ({ streamBuffer, }: {
     streamBuffer: TransportStreamPacketBuffer;
@@ -12,9 +12,9 @@ export declare const processVideo: ({ programId, structure, streamBuffer, sample
     structure: TransportStreamStructure;
     streamBuffer: TransportStreamPacketBuffer;
     sampleCallbacks: CallbacksState;
-    logLevel: LogLevel;
-    onAudioTrack: OnAudioTrack | null;
-    onVideoTrack: OnVideoTrack | null;
+    logLevel: MediaParserLogLevel;
+    onAudioTrack: MediaParserOnAudioTrack | null;
+    onVideoTrack: MediaParserOnVideoTrack | null;
     transportStream: TransportStreamState;
     makeSamplesStartAtZero: boolean;
 }) => Promise<Uint8Array>;

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

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

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

@@ -1,3 +1,3 @@
-import type { VideoTrackColorParams } from '../../get-tracks';
+import type { MediaParserAdvancedColor } from '../../get-tracks';
 import type { ColourSegment } from './segments/all-segments';
-export declare const parseColorSegment: (colourSegment: ColourSegment) => VideoTrackColorParams;
+export declare const parseColorSegment: (colourSegment: ColourSegment) => MediaParserAdvancedColor;

package/dist/containers/webm/color.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseColorSegment = void 0;
+const color_1 = require("../avc/color");
 const traversal_1 = require("./traversal");
 const parseColorSegment = (colourSegment) => {
     const transferCharacteristics = (0, traversal_1.getTransferCharacteristicsSegment)(colourSegment);
@@ -8,33 +9,13 @@ const parseColorSegment = (colourSegment) => {
     const primaries = (0, traversal_1.getPrimariesSegment)(colourSegment);
     const range = (0, traversal_1.getRangeSegment)(colourSegment);
     return {
-        transferCharacteristics: transferCharacteristics
-            ? transferCharacteristics.value.value === 1
-                ? 'bt709'
-                : transferCharacteristics.value.value === 6
-                    ? 'smpte170m'
-                    : transferCharacteristics.value.value === 13
-                        ? 'iec61966-2-1'
-                        : null
+        transfer: transferCharacteristics
+            ? (0, color_1.getTransferCharacteristicsFromIndex)(transferCharacteristics.value.value)
             : null,
-        matrixCoefficients: matrixCoefficients
-            ? matrixCoefficients.value.value === 1
-                ? 'bt709'
-                : matrixCoefficients.value.value === 6
-                    ? 'smpte170m'
-                    : matrixCoefficients.value.value === 5
-                        ? 'bt470bg'
-                        : null
-            : null,
-        primaries: primaries
-            ? primaries.value.value === 1
-                ? 'bt709'
-                : primaries.value.value === 6
-                    ? 'smpte170m'
-                    : primaries.value.value === 5
-                        ? 'bt470bg'
-                        : null
+        matrix: matrixCoefficients
+            ? (0, color_1.getMatrixCoefficientsFromIndex)(matrixCoefficients.value.value)
             : null,
+        primaries: primaries ? (0, color_1.getPrimariesFromIndex)(primaries.value.value) : null,
         fullRange: (transferCharacteristics === null || transferCharacteristics === void 0 ? void 0 : transferCharacteristics.value.value) && (matrixCoefficients === null || matrixCoefficients === void 0 ? void 0 : matrixCoefficients.value.value)
             ? null
             : range

package/dist/containers/webm/get-ready-tracks.d.ts

@@ -1,9 +1,9 @@
-import type { Track } from '../../get-tracks';
+import type { MediaParserTrack } from '../../get-tracks';
 import type { WebmState } from '../../state/matroska/webm';
 import type { StructureState } from '../../state/structure';
 export type ResolvedAndUnresolvedTracks = {
-    resolved: Track[];
-    missingInfo: Track[];
+    resolved: MediaParserTrack[];
+    missingInfo: MediaParserTrack[];
 };
 export declare const getTracksFromMatroska: ({ structureState, webmState, }: {
     structureState: StructureState;

package/dist/containers/webm/get-sample-from-block.d.ts

@@ -1,18 +1,18 @@
-import type { LogLevel } from '../../log';
+import type { MediaParserLogLevel } from '../../log';
 import type { WebmState } from '../../state/matroska/webm';
 import type { CallbacksState } from '../../state/sample-callbacks';
 import type { StructureState } from '../../state/structure';
-import type { AudioOrVideoSample, OnVideoTrack } from '../../webcodec-sample-types';
+import type { MediaParserAudioSample, MediaParserOnVideoTrack, MediaParserVideoSample } from '../../webcodec-sample-types';
 import type { BlockSegment, SimpleBlockSegment } from './segments/all-segments';
 type SampleResult = {
     type: 'video-sample';
-    videoSample: AudioOrVideoSample;
+    videoSample: MediaParserVideoSample;
 } | {
     type: 'audio-sample';
-    audioSample: AudioOrVideoSample;
+    audioSample: MediaParserAudioSample;
 } | {
     type: 'partial-video-sample';
-    partialVideoSample: Omit<AudioOrVideoSample, 'type'>;
+    partialVideoSample: Omit<MediaParserVideoSample, 'type'>;
 } | {
     type: 'no-sample';
 };
@@ -22,7 +22,7 @@ export declare const getSampleFromBlock: ({ ebml, webmState, offset, structureSt
     offset: number;
     structureState: StructureState;
     callbacks: CallbacksState;
-    logLevel: LogLevel;
-    onVideoTrack: OnVideoTrack | null;
+    logLevel: MediaParserLogLevel;
+    onVideoTrack: MediaParserOnVideoTrack | null;
 }) => Promise<SampleResult>;
 export {};

package/dist/containers/webm/make-track.d.ts

@@ -1,10 +1,10 @@
-import type { AudioTrack, MediaParserAudioCodec, VideoTrack } from '../../get-tracks';
+import type { MediaParserAudioCodec, MediaParserAudioTrack, MediaParserVideoTrack } from '../../get-tracks';
 import type { TrackEntry } from './segments/all-segments';
 export declare const NO_CODEC_PRIVATE_SHOULD_BE_DERIVED_FROM_SPS = "no-codec-private-should-be-derived-from-sps";
-export declare const getMatroskaAudioCodecWithoutConfigString: ({ track, }: {
+export declare const getMatroskaAudioCodecEnum: ({ track, }: {
     track: TrackEntry;
 }) => MediaParserAudioCodec;
 export declare const getTrack: ({ timescale, track, }: {
     timescale: number;
     track: TrackEntry;
-}) => VideoTrack | AudioTrack | null;
+}) => MediaParserVideoTrack | MediaParserAudioTrack | null;

package/dist/containers/webm/make-track.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTrack = exports.getMatroskaAudioCodecWithoutConfigString = exports.NO_CODEC_PRIVATE_SHOULD_BE_DERIVED_FROM_SPS = void 0;
+exports.getTrack = exports.getMatroskaAudioCodecEnum = exports.NO_CODEC_PRIVATE_SHOULD_BE_DERIVED_FROM_SPS = void 0;
 const buffer_iterator_1 = require("../../iterator/buffer-iterator");
 const make_hvc1_codec_strings_1 = require("../../make-hvc1-codec-strings");
+const color_to_webcodecs_colors_1 = require("../iso-base-media/color-to-webcodecs-colors");
 const av1_codec_private_1 = require("./av1-codec-private");
 const color_1 = require("./color");
 const description_1 = require("./description");
@@ -22,7 +23,7 @@ const getDescription = (track) => {
     }
     return undefined;
 };
-const getMatroskaVideoCodecWithoutConfigString = ({ codecSegment: codec, }) => {
+const getMatroskaVideoCodecEnum = ({ codecSegment: codec, }) => {
     if (codec.value === 'V_VP8') {
         return 'vp8';
     }
@@ -72,7 +73,7 @@ const getMatroskaVideoCodecString = ({ track, codecSegment: codec, }) => {
     }
     throw new Error(`Unknown codec: ${codec.value}`);
 };
-const getMatroskaAudioCodecWithoutConfigString = ({ track, }) => {
+const getMatroskaAudioCodecEnum = ({ track, }) => {
     const codec = (0, traversal_1.getCodecSegment)(track);
     if (!codec) {
         throw new Error('Expected codec segment');
@@ -109,7 +110,7 @@ const getMatroskaAudioCodecWithoutConfigString = ({ track, }) => {
     }
     throw new Error(`Unknown codec: ${codec.value}`);
 };
-exports.getMatroskaAudioCodecWithoutConfigString = getMatroskaAudioCodecWithoutConfigString;
+exports.getMatroskaAudioCodecEnum = getMatroskaAudioCodecEnum;
 const getMatroskaAudioCodecString = (track) => {
     const codec = (0, traversal_1.getCodecSegment)(track);
     if (!codec) {
@@ -198,6 +199,42 @@ const getTrack = ({ timescale, track, }) => {
         if (!codecString) {
             return null;
         }
+        const codecEnum = getMatroskaVideoCodecEnum({
+            codecSegment: codec,
+        });
+        const codecData = codecPrivate === null
+            ? null
+            : codecEnum === 'h264'
+                ? { type: 'avc-sps-pps', data: codecPrivate }
+                : codecEnum === 'av1'
+                    ? {
+                        type: 'av1c-data',
+                        data: codecPrivate,
+                    }
+                    : codecEnum === 'h265'
+                        ? {
+                            type: 'hvcc-data',
+                            data: codecPrivate,
+                        }
+                        : codecEnum === 'vp8'
+                            ? {
+                                type: 'unknown-data',
+                                data: codecPrivate,
+                            }
+                            : codecEnum === 'vp9'
+                                ? {
+                                    type: 'unknown-data',
+                                    data: codecPrivate,
+                                }
+                                : null;
+        const advancedColor = colour
+            ? (0, color_1.parseColorSegment)(colour)
+            : {
+                fullRange: null,
+                matrix: null,
+                primaries: null,
+                transfer: null,
+            };
         return {
             m3uStreamFormat: null,
             type: 'video',
@@ -220,19 +257,10 @@ const getTrack = ({ timescale, track, }) => {
                 ? displayWidth.value.value
                 : width.value.value,
             rotation: 0,
-            trakBox: null,
-            codecPrivate,
-            color: colour
-                ? (0, color_1.parseColorSegment)(colour)
-                : {
-                    fullRange: null,
-                    matrixCoefficients: null,
-                    primaries: null,
-                    transferCharacteristics: null,
-                },
-            codecWithoutConfig: getMatroskaVideoCodecWithoutConfigString({
-                codecSegment: codec,
-            }),
+            codecData,
+            colorSpace: (0, color_to_webcodecs_colors_1.mediaParserAdvancedColorToWebCodecsColor)(advancedColor),
+            advancedColor,
+            codecEnum,
             fps: null,
         };
     }
@@ -243,17 +271,21 @@ const getTrack = ({ timescale, track, }) => {
         if (sampleRate === null) {
             throw new Error('Could not find sample rate or number of channels');
         }
+        const codecString = getMatroskaAudioCodecString(track);
         return {
             type: 'audio',
             trackId,
-            codec: getMatroskaAudioCodecString(track),
+            codec: codecString,
             timescale,
             numberOfChannels,
             sampleRate,
             description: (0, description_1.getAudioDescription)(track),
-            trakBox: null,
-            codecPrivate,
-            codecWithoutConfig: (0, exports.getMatroskaAudioCodecWithoutConfigString)({
+            codecData: codecPrivate
+                ? codecString === 'opus'
+                    ? { type: 'ogg-identification', data: codecPrivate }
+                    : { type: 'unknown-data', data: codecPrivate }
+                : null,
+            codecEnum: (0, exports.getMatroskaAudioCodecEnum)({
                 track,
             }),
         };

package/dist/containers/webm/parse-webm-header.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseWebm = void 0;
+const skip_1 = require("../../skip");
+const may_skip_video_data_1 = require("../../state/may-skip-video-data");
 const get_byte_for_cues_1 = require("./get-byte-for-cues");
 const segments_1 = require("./segments");
 const state_for_processing_1 = require("./state-for-processing");
@@ -28,6 +30,9 @@ const parseWebm = async (state) => {
         return null;
     }
     if (isInsideCluster) {
+        if ((0, may_skip_video_data_1.maySkipVideoData)({ state })) {
+            return (0, skip_1.makeSkip)(Math.min(state.contentLength, isInsideCluster.size + isInsideCluster.start));
+        }
         const segments = structure.boxes.filter((box) => box.type === 'Segment');
         const segment = segments[isInsideCluster.segment];
         if (!segment) {