@remotion/media-parser 4.0.266 → 4.0.268

package/dist/containers/flac/get-channel-count.d.ts

@@ -1,2 +1,2 @@
 import type { BufferIterator } from '../../buffer-iterator';
-export declare const getChannelCount: (iterator: BufferIterator) => 2 | 1 | 8 | 7 | 3 | 6 | 5 | 4;
+export declare const getChannelCount: (iterator: BufferIterator) => 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;

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

@@ -1,6 +1,15 @@
 import type { Dimensions } from '../../get-dimensions';
 import type { Structure } from '../../parse-result';
 import type { ParserState } from '../../state/parser-state';
+export type M3uStreamAudioTrack = {
+    groupId: string;
+    language: string | null;
+    name: string | null;
+    autoselect: boolean;
+    default: boolean;
+    channels: number | null;
+    url: string;
+};
 export type M3uStream = {
     url: string;
     bandwidth: number | null;
@@ -8,6 +17,7 @@ export type M3uStream = {
     resolution: Dimensions | null;
     codecs: string[] | null;
     id: number;
+    dedicatedAudioTracks: M3uStreamAudioTrack[];
 };
 export declare const isIndependentSegments: (structure: Structure | null) => boolean;
 export declare const getM3uStreams: (structure: Structure | null, originalSrc: string | null) => M3uStream[] | null;

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

@@ -20,6 +20,25 @@ const getM3uStreams = (structure, originalSrc) => {
             if (next.type !== 'm3u-text-value') {
                 throw new Error('Expected m3u-text-value');
             }
+            const dedicatedAudioTracks = [];
+            if (str.audio) {
+                const match = structure.boxes.filter((box) => {
+                    return box.type === 'm3u-media-info' && box.groupId === str.audio;
+                });
+                for (const audioTrack of match) {
+                    dedicatedAudioTracks.push({
+                        autoselect: audioTrack.autoselect,
+                        channels: audioTrack.channels,
+                        default: audioTrack.default,
+                        groupId: audioTrack.groupId,
+                        language: audioTrack.language,
+                        name: audioTrack.name,
+                        url: originalSrc && originalSrc.startsWith('http')
+                            ? new URL(audioTrack.uri, originalSrc).href
+                            : audioTrack.uri,
+                    });
+                }
+            }
             boxes.push({
                 url: originalSrc && originalSrc.startsWith('http')
                     ? new URL(next.value, originalSrc).href
@@ -28,6 +47,7 @@ const getM3uStreams = (structure, originalSrc) => {
                 bandwidth: str.bandwidth,
                 codecs: str.codecs,
                 resolution: str.resolution,
+                dedicatedAudioTracks,
             });
         }
     }

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseM3uDirective = void 0;
+const parse_m3u_media_directive_1 = require("./parse-m3u-media-directive");
 const parse_stream_inf_1 = require("./parse-stream-inf");
 const parseM3uDirective = (str) => {
     const firstColon = str.indexOf(':');
@@ -20,6 +21,13 @@ const parseM3uDirective = (str) => {
             type: 'm3u-independent-segments',
         };
     }
+    if (directive === '#EXT-X-MEDIA') {
+        if (!value) {
+            throw new Error('EXT-X-MEDIA directive must have a value');
+        }
+        const parsed = (0, parse_m3u_media_directive_1.parseM3uMediaDirective)(value);
+        return parsed;
+    }
     if (directive === '#EXT-X-TARGETDURATION') {
         if (!value) {
             throw new Error('EXT-X-TARGETDURATION directive must have a value');

package/dist/containers/m3u/parse-m3u-media-directive.d.ts

@@ -0,0 +1,2 @@
+import type { M3uMediaInfo } from './types';
+export declare const parseM3uMediaDirective: (str: string) => M3uMediaInfo;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseM3uMediaDirective = void 0;
+const parse_stream_inf_1 = require("./parse-stream-inf");
+const parseM3uMediaDirective = (str) => {
+    const quotes = (0, parse_stream_inf_1.splitRespectingQuotes)(str);
+    const map = {};
+    for (const quote of quotes) {
+        const firstColon = quote.indexOf('=');
+        const key = firstColon === -1 ? quote : quote.slice(0, firstColon);
+        const value = firstColon === -1 ? null : quote.slice(firstColon + 1);
+        if (value === null) {
+            throw new Error('Value is null');
+        }
+        const actualValue = (value === null || value === void 0 ? void 0 : value.startsWith('"')) && (value === null || value === void 0 ? void 0 : value.endsWith('"'))
+            ? value.slice(1, -1)
+            : value;
+        map[key] = actualValue;
+    }
+    return {
+        type: 'm3u-media-info',
+        autoselect: map.AUTOSELECT === 'YES',
+        channels: map.CHANNELS ? parseInt(map.CHANNELS, 10) : null,
+        default: map.DEFAULT === 'YES',
+        groupId: map['GROUP-ID'],
+        language: map.LANGUAGE || null,
+        name: map.NAME || null,
+        uri: map.URI,
+    };
+};
+exports.parseM3uMediaDirective = parseM3uMediaDirective;

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

@@ -56,6 +56,7 @@ const parseStreamInf = (str) => {
                 height: parseInt(map.RESOLUTION.split('x')[1], 10),
             }
             : null,
+        audio: map.AUDIO || null,
     };
 };
 exports.parseStreamInf = parseStreamInf;

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

@@ -8,6 +8,9 @@ export type M3uVersion = {
 export type M3uIndependentSegments = {
     type: 'm3u-independent-segments';
 };
+export type M3uMedia = {
+    type: 'm3u-media';
+};
 export type M3uTargetDuration = {
     type: 'm3u-target-duration';
     duration: number;
@@ -36,12 +39,23 @@ export type M3uStreamInfo = {
         width: number;
         height: number;
     } | null;
+    audio: string | null;
+};
+export type M3uMediaInfo = {
+    type: 'm3u-media-info';
+    groupId: string;
+    language: string | null;
+    name: string | null;
+    autoselect: boolean;
+    default: boolean;
+    channels: number | null;
+    uri: string;
 };
 export type M3uTextValue = {
     type: 'm3u-text-value';
     value: string;
 };
-export type M3uBox = M3uHeader | M3uPlaylist | M3uVersion | M3uIndependentSegments | M3uStreamInfo | M3uTargetDuration | M3uPlaylistType | M3uExtInf | M3uEndList | M3uTextValue;
+export type M3uBox = M3uHeader | M3uPlaylist | M3uVersion | M3uIndependentSegments | M3uStreamInfo | M3uTargetDuration | M3uPlaylistType | M3uExtInf | M3uMedia | M3uMediaInfo | M3uEndList | M3uTextValue;
 export type M3uStructure = {
     type: 'm3u';
     boxes: M3uBox[];

package/dist/containers/mp3/get-duration.js

@@ -5,15 +5,16 @@ const get_frame_length_1 = require("./get-frame-length");
 const samples_per_mpeg_file_1 = require("./samples-per-mpeg-file");
 const getDurationFromMp3 = (state) => {
     const mp3Info = state.mp3Info.getMp3Info();
-    if (!mp3Info) {
-        throw new Error('No mp3 info');
+    const mp3CbrInfo = state.mp3Info.getCbrMp3Info();
+    if (!mp3Info || !mp3CbrInfo) {
+        return null;
     }
     const samplesPerFrame = (0, samples_per_mpeg_file_1.getSamplesPerMpegFrame)({
         layer: mp3Info.layer,
         mpegVersion: mp3Info.mpegVersion,
     });
     const frameLengthInBytes = (0, get_frame_length_1.getMpegFrameLength)({
-        bitrateKbit: mp3Info.bitrateKbit,
+        bitrateKbit: mp3CbrInfo.bitrateKbit,
         padding: false,
         samplesPerFrame,
         samplingFrequency: mp3Info.sampleRate,

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

@@ -2,6 +2,7 @@
 // spec: http://www.mp3-tech.org/programmer/frame_header.html
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMpegHeader = void 0;
+const log_1 = require("../../log");
 const register_track_1 = require("../../register-track");
 const get_frame_length_1 = require("./get-frame-length");
 const samples_per_mpeg_file_1 = require("./samples-per-mpeg-file");
@@ -219,35 +220,45 @@ const parseMpegHeader = async ({ state, }) => {
     const offsetNow = iterator.counter.getOffset();
     iterator.counter.decrement(offsetNow - initialOffset);
     const data = iterator.getSlice(frameLength);
+    let isInfoTag = false;
     if (state.callbacks.tracks.getTracks().length === 0) {
-        state.mp3Info.setMp3Info({
+        const info = {
             layer,
             mpegVersion,
             sampleRate,
-            bitrateKbit,
             startOfMpegStream: initialOffset,
-        });
-        await (0, register_track_1.registerAudioTrack)({
-            container: 'mp3',
-            state,
-            track: {
-                type: 'audio',
-                codec: 'mp3',
-                codecPrivate: null,
-                codecWithoutConfig: 'mp3',
-                description: undefined,
-                numberOfChannels,
-                sampleRate,
-                timescale: 1000000,
-                trackId: 0,
-                trakBox: null,
-            },
-        });
-        state.callbacks.tracks.setIsDone(state.logLevel);
-    }
-    const mp3Info = state.mp3Info.getMp3Info();
-    if (!mp3Info) {
-        throw new Error('No MP3 info by now');
+        };
+        const asText = new TextDecoder().decode(data);
+        const isVbr = asText.includes('Xing') || asText.includes('VBRI');
+        isInfoTag = isVbr || asText.includes('Info');
+        if (isVbr) {
+            log_1.Log.verbose(state.logLevel, 'MP3 has variable bit rate. Requiring whole file to be read');
+        }
+        else {
+            state.mp3Info.setCbrMp3Info({
+                bitrateKbit,
+            });
+        }
+        if (!isInfoTag) {
+            state.mp3Info.setMp3Info(info);
+            await (0, register_track_1.registerAudioTrack)({
+                container: 'mp3',
+                state,
+                track: {
+                    type: 'audio',
+                    codec: 'mp3',
+                    codecPrivate: null,
+                    codecWithoutConfig: 'mp3',
+                    description: undefined,
+                    numberOfChannels,
+                    sampleRate,
+                    timescale: 1000000,
+                    trackId: 0,
+                    trakBox: null,
+                },
+            });
+            state.callbacks.tracks.setIsDone(state.logLevel);
+        }
     }
     const avgLength = (0, get_frame_length_1.getAverageMpegFrameLength)({
         bitrateKbit,
@@ -255,21 +266,27 @@ const parseMpegHeader = async ({ state, }) => {
         samplesPerFrame,
         samplingFrequency: sampleRate,
     });
-    const nthFrame = Math.round((initialOffset - mp3Info.startOfMpegStream) / avgLength);
-    const durationInSeconds = samplesPerFrame / sampleRate;
-    const timeInSeconds = (nthFrame * samplesPerFrame) / sampleRate;
-    const timestamp = Math.round(timeInSeconds * 1000000);
-    const duration = Math.round(durationInSeconds * 1000000);
-    await state.callbacks.onAudioSample(0, {
-        data,
-        cts: timestamp,
-        dts: timestamp,
-        duration,
-        offset: initialOffset,
-        timescale: 1000000,
-        timestamp,
-        trackId: 0,
-        type: 'key',
-    });
+    if (!isInfoTag) {
+        const mp3Info = state.mp3Info.getMp3Info();
+        if (!mp3Info) {
+            throw new Error('No MP3 info');
+        }
+        const nthFrame = Math.round((initialOffset - mp3Info.startOfMpegStream) / avgLength);
+        const durationInSeconds = samplesPerFrame / sampleRate;
+        const timeInSeconds = (nthFrame * samplesPerFrame) / sampleRate;
+        const timestamp = Math.round(timeInSeconds * 1000000);
+        const duration = Math.round(durationInSeconds * 1000000);
+        await state.callbacks.onAudioSample(0, {
+            data,
+            cts: timestamp,
+            dts: timestamp,
+            duration,
+            offset: initialOffset,
+            timescale: 1000000,
+            timestamp,
+            trackId: 0,
+            type: 'key',
+        });
+    }
 };
 exports.parseMpegHeader = parseMpegHeader;

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

@@ -1,3 +1,10 @@
 import type { Track } from '../../get-tracks';
-import type { MainSegment } from './segments/all-segments';
-export declare const getTracksFromMatroska: (segment: MainSegment, timescale: number) => Track[];
+import type { ParserState } from '../../state/parser-state';
+export type ResolvedAndUnresolvedTracks = {
+    resolved: Track[];
+    missingInfo: Track[];
+};
+export declare const getTracksFromMatroska: ({ state, }: {
+    state: ParserState;
+}) => ResolvedAndUnresolvedTracks;
+export declare const matroskaHasTracks: (state: ParserState) => boolean;

package/dist/containers/webm/get-ready-tracks.js

@@ -1,14 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTracksFromMatroska = void 0;
+exports.matroskaHasTracks = exports.getTracksFromMatroska = void 0;
+const codec_string_1 = require("../avc/codec-string");
 const make_track_1 = require("./make-track");
 const traversal_1 = require("./traversal");
-const getTracksFromMatroska = (segment, timescale) => {
-    const tracksSegment = (0, traversal_1.getTracksSegment)(segment);
+const getTracksFromMatroska = ({ state, }) => {
+    const webmState = state.webm;
+    const structure = state.getMatroskaStructure();
+    const mainSegment = (0, traversal_1.getMainSegment)(structure.boxes);
+    if (!mainSegment) {
+        throw new Error('No main segment');
+    }
+    const tracksSegment = (0, traversal_1.getTracksSegment)(mainSegment);
     if (!tracksSegment) {
         throw new Error('No tracks segment');
     }
-    const tracks = [];
+    const resolvedTracks = [];
+    const missingInfo = [];
     for (const trackEntrySegment of tracksSegment.value) {
         if (trackEntrySegment.type === 'Crc32') {
             continue;
@@ -18,12 +26,39 @@ const getTracksFromMatroska = (segment, timescale) => {
         }
         const track = (0, make_track_1.getTrack)({
             track: trackEntrySegment,
-            timescale,
+            timescale: webmState.getTimescale(),
         });
-        if (track) {
-            tracks.push(track);
+        if (!track) {
+            continue;
+        }
+        if (track.codec === make_track_1.NO_CODEC_PRIVATE_SHOULD_BE_DERIVED_FROM_SPS) {
+            const avc = webmState.getAvcProfileForTrackNumber(track.trackId);
+            if (avc) {
+                resolvedTracks.push({
+                    ...track,
+                    codec: (0, codec_string_1.getCodecStringFromSpsAndPps)(avc),
+                });
+            }
+            else {
+                missingInfo.push(track);
+            }
+        }
+        else {
+            resolvedTracks.push(track);
         }
     }
-    return tracks;
+    return { missingInfo, resolved: resolvedTracks };
 };
 exports.getTracksFromMatroska = getTracksFromMatroska;
+const matroskaHasTracks = (state) => {
+    const structure = state.getMatroskaStructure();
+    const mainSegment = (0, traversal_1.getMainSegment)(structure.boxes);
+    if (!mainSegment) {
+        return false;
+    }
+    return ((0, traversal_1.getTracksSegment)(mainSegment) !== null &&
+        (0, exports.getTracksFromMatroska)({
+            state,
+        }).missingInfo.length === 0);
+};
+exports.matroskaHasTracks = matroskaHasTracks;

package/dist/containers/webm/get-sample-from-block.js

@@ -2,8 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSampleFromBlock = void 0;
 const buffer_iterator_1 = require("../../buffer-iterator");
+const parse_avc_1 = require("../avc/parse-avc");
+const get_ready_tracks_1 = require("./get-ready-tracks");
 const all_segments_1 = require("./segments/all-segments");
 const block_simple_block_flags_1 = require("./segments/block-simple-block-flags");
+const addAvcToTrackIfNecessary = ({ partialVideoSample, codec, state, trackNumber, }) => {
+    if (codec === 'V_MPEG4/ISO/AVC' &&
+        (0, get_ready_tracks_1.getTracksFromMatroska)({ state }).missingInfo.length > 0) {
+        const parsed = (0, parse_avc_1.parseAvc)(partialVideoSample.data);
+        for (const parse of parsed) {
+            if (parse.type === 'avc-profile') {
+                state.webm.setAvcProfileForTrackNumber(trackNumber, parse);
+            }
+        }
+    }
+};
 const getSampleFromBlock = (ebml, state, offset) => {
     const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(ebml.value, ebml.value.length);
     const trackNumber = iterator.getVint();
@@ -49,6 +62,12 @@ const getSampleFromBlock = (ebml, state, offset) => {
                 partialVideoSample,
             };
         }
+        addAvcToTrackIfNecessary({
+            codec,
+            partialVideoSample,
+            state,
+            trackNumber,
+        });
         const sample = {
             ...partialVideoSample,
             type: keyframe ? 'key' : 'delta',

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

@@ -1,5 +1,6 @@
 import type { AudioTrack, MediaParserAudioCodec, VideoTrack } 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, }: {
     track: TrackEntry;
 }) => MediaParserAudioCodec;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTrack = exports.getMatroskaAudioCodecWithoutConfigString = void 0;
+exports.getTrack = exports.getMatroskaAudioCodecWithoutConfigString = exports.NO_CODEC_PRIVATE_SHOULD_BE_DERIVED_FROM_SPS = void 0;
 const buffer_iterator_1 = require("../../buffer-iterator");
 const make_hvc1_codec_strings_1 = require("../../make-hvc1-codec-strings");
 const av1_codec_private_1 = require("./av1-codec-private");
@@ -8,6 +8,7 @@ const color_1 = require("./color");
 const description_1 = require("./description");
 const track_entry_1 = require("./segments/track-entry");
 const traversal_1 = require("./traversal");
+exports.NO_CODEC_PRIVATE_SHOULD_BE_DERIVED_FROM_SPS = 'no-codec-private-should-be-derived-from-sps';
 const getDescription = (track) => {
     const codec = (0, traversal_1.getCodecSegment)(track);
     if (!codec) {
@@ -46,7 +47,7 @@ const getMatroskaVideoCodecString = ({ track, codecSegment: codec, }) => {
     if (codec.value === 'V_VP9') {
         const priv = (0, traversal_1.getPrivateData)(track);
         if (priv) {
-            throw new Error('@remotion/media-parser cannot handle the private data for VP9. Do you have an example file you could send so we can implement it?');
+            throw new Error('@remotion/media-parser cannot handle the private data for VP9. Do you have an example file you could send so we can implement it? https://remotion.dev/report');
         }
         return 'vp09.00.10.08';
     }
@@ -55,7 +56,12 @@ const getMatroskaVideoCodecString = ({ track, codecSegment: codec, }) => {
         if (priv) {
             return `avc1.${priv[1].toString(16).padStart(2, '0')}${priv[2].toString(16).padStart(2, '0')}${priv[3].toString(16).padStart(2, '0')}`;
         }
-        throw new Error('Could not find a CodecPrivate field in TrackEntry');
+        return exports.NO_CODEC_PRIVATE_SHOULD_BE_DERIVED_FROM_SPS;
+    }
+    if (codec.value === 'V_MPEGH/ISO/HEVC') {
+        const priv = (0, traversal_1.getPrivateData)(track);
+        const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(priv, priv.length);
+        return 'hvc1.' + (0, make_hvc1_codec_strings_1.getHvc1CodecString)(iterator);
     }
     if (codec.value === 'V_AV1') {
         const priv = (0, traversal_1.getPrivateData)(track);
@@ -64,11 +70,6 @@ const getMatroskaVideoCodecString = ({ track, codecSegment: codec, }) => {
         }
         return (0, av1_codec_private_1.parseAv1PrivateData)(priv, null);
     }
-    if (codec.value === 'V_MPEGH/ISO/HEVC') {
-        const priv = (0, traversal_1.getPrivateData)(track);
-        const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(priv, priv.length);
-        return 'hvc1.' + (0, make_hvc1_codec_strings_1.getHvc1CodecString)(iterator);
-    }
     throw new Error(`Unknown codec: ${codec.value}`);
 };
 const getMatroskaAudioCodecWithoutConfigString = ({ track, }) => {