@remotion/media-parser 4.0.271 → 4.0.273

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 | 8 | 1 | 7 | 3 | 4 | 5 | 6;
+export declare const getChannelCount: (iterator: BufferIterator) => 2 | 8 | 1 | 7 | 3 | 5 | 4 | 6;

package/dist/containers/flac/get-metadata-from-flac.d.ts

@@ -1,2 +1,2 @@
 import type { FlacStructure } from './types';
-export declare const getMetadataFromFlac: (structure: FlacStructure) => import("../..").MetadataEntry[] | null;
+export declare const getMetadataFromFlac: (structure: FlacStructure) => import("../..").MediaParserMetadataEntry[] | null;

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

@@ -0,0 +1,5 @@
+import type { SamplePosition } from '../../get-sample-positions';
+import type { IsoBaseMediaSeekingInfo, SeekingInfo } from '../../seeking-info';
+import type { ParserState } from '../../state/parser-state';
+export declare const getSeekingInfoFromMp4: (state: ParserState) => SeekingInfo | null;
+export declare const getSeekingByteFromIsoBaseMedia: (info: IsoBaseMediaSeekingInfo, time: number) => SamplePosition;

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

@@ -0,0 +1,50 @@
+import { getTracksFromMoovBox } from '../../get-tracks';
+import { getSamplePositionsFromTrack } from './get-sample-positions-from-track';
+import { getMoofBoxes, getMoovBoxFromState } from './traversal';
+export const getSeekingInfoFromMp4 = (state) => {
+    const structure = state.getIsoStructure();
+    const moovAtom = getMoovBoxFromState(state);
+    const moofBoxes = getMoofBoxes(structure.boxes);
+    if (!moovAtom) {
+        return null;
+    }
+    return {
+        type: 'iso-base-media-seeking-info',
+        moovBox: moovAtom,
+        moofBoxes,
+    };
+};
+export const getSeekingByteFromIsoBaseMedia = (info, time) => {
+    const tracks = getTracksFromMoovBox(info.moovBox);
+    const allTracks = [
+        ...tracks.videoTracks,
+        ...tracks.audioTracks,
+        ...tracks.otherTracks,
+    ];
+    let byte = 0;
+    let sam = null;
+    for (const t of allTracks) {
+        const { timescale: ts, type } = t;
+        if (type !== 'video') {
+            continue;
+        }
+        const samplePositions = getSamplePositionsFromTrack({
+            trakBox: t.trakBox,
+            moofBoxes: info.moofBoxes,
+        });
+        for (const sample of samplePositions) {
+            const timestamp = sample.cts / ts;
+            if (timestamp <= time &&
+                byte < sample.offset &&
+                type === 'video' &&
+                sample.isKeyframe) {
+                byte = sample.offset;
+                sam = sample;
+            }
+        }
+    }
+    if (!sam) {
+        throw new Error('No sample found');
+    }
+    return sam;
+};

package/dist/containers/m3u/iterate-over-segment-files.d.ts

@@ -7,8 +7,8 @@ import type { OnAudioSample, OnVideoSample } from '../../webcodec-sample-types';
 import type { M3uStructure } from './types';
 export declare const iteratorOverSegmentFiles: ({ structure, onVideoTrack, m3uState, onAudioTrack, onDoneWithTracks, playlistUrl, logLevel, parentController, onInitialProgress, readerInterface, }: {
     structure: M3uStructure;
-    onVideoTrack: (track: VideoTrack) => Promise<OnVideoSample | null>;
-    onAudioTrack: (track: AudioTrack) => Promise<OnAudioSample | null>;
+    onVideoTrack: null | ((track: VideoTrack) => Promise<OnVideoSample | null>);
+    onAudioTrack: null | ((track: AudioTrack) => Promise<OnAudioSample | null>);
     onDoneWithTracks: () => void;
     m3uState: M3uState;
     playlistUrl: string;

package/dist/containers/m3u/iterate-over-segment-files.js

@@ -52,36 +52,40 @@ export const iteratorOverSegmentFiles = async ({ structure, onVideoTrack, m3uSta
                         return null;
                     }
                 },
-                onAudioTrack: async ({ track }) => {
-                    const callbackOrFalse = m3uState.hasEmittedAudioTrack(playlistUrl);
-                    if (callbackOrFalse === false) {
-                        const callback = await onAudioTrack(track);
-                        if (!callback) {
-                            m3uState.setHasEmittedAudioTrack(playlistUrl, null);
-                            return null;
+                onAudioTrack: onAudioTrack === null
+                    ? null
+                    : async ({ track }) => {
+                        const callbackOrFalse = m3uState.hasEmittedAudioTrack(playlistUrl);
+                        if (callbackOrFalse === false) {
+                            const callback = await onAudioTrack(track);
+                            if (!callback) {
+                                m3uState.setHasEmittedAudioTrack(playlistUrl, null);
+                                return null;
+                            }
+                            m3uState.setHasEmittedAudioTrack(playlistUrl, callback);
+                            return (sample) => {
+                                return callback(sample);
+                            };
                         }
-                        m3uState.setHasEmittedAudioTrack(playlistUrl, callback);
-                        return (sample) => {
-                            return callback(sample);
-                        };
-                    }
-                    return callbackOrFalse;
-                },
-                onVideoTrack: async ({ track }) => {
-                    const callbackOrFalse = m3uState.hasEmittedVideoTrack(playlistUrl);
-                    if (callbackOrFalse === false) {
-                        const callback = await onVideoTrack(track);
-                        if (!callback) {
-                            m3uState.setHasEmittedVideoTrack(playlistUrl, null);
-                            return null;
+                        return callbackOrFalse;
+                    },
+                onVideoTrack: onVideoTrack === null
+                    ? null
+                    : async ({ track }) => {
+                        const callbackOrFalse = m3uState.hasEmittedVideoTrack(playlistUrl);
+                        if (callbackOrFalse === false) {
+                            const callback = await onVideoTrack(track);
+                            if (!callback) {
+                                m3uState.setHasEmittedVideoTrack(playlistUrl, null);
+                                return null;
+                            }
+                            m3uState.setHasEmittedVideoTrack(playlistUrl, callback);
+                            return (sample) => {
+                                return callback(sample);
+                            };
                         }
-                        m3uState.setHasEmittedVideoTrack(playlistUrl, callback);
-                        return (sample) => {
-                            return callback(sample);
-                        };
-                    }
-                    return callbackOrFalse;
-                },
+                        return callbackOrFalse;
+                    },
                 reader: readerInterface,
                 mp4HeaderSegment,
             });

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

@@ -82,6 +82,20 @@ export const parseM3uDirective = (str) => {
         const res = parseStreamInf(value);
         return res;
     }
+    if (directive === '#EXT-X-I-FRAME-STREAM-INF') {
+        return {
+            type: 'm3u-i-frame-stream-info',
+        };
+    }
+    if (directive === '#EXT-X-ALLOW-CACHE') {
+        if (!value) {
+            throw new Error('#EXT-X-ALLOW-CACHE directive must have a value');
+        }
+        return {
+            type: 'm3u-allow-cache',
+            allowsCache: value === 'YES',
+        };
+    }
     if (directive === '#EXT-X-MAP') {
         if (!value) {
             throw new Error('#EXT-X-MAP directive must have a value');

package/dist/containers/m3u/run-over-m3u.js

@@ -2,6 +2,16 @@ import { Log } from '../../log';
 import { registerAudioTrack, registerVideoTrack } from '../../register-track';
 import { iteratorOverSegmentFiles } from './iterate-over-segment-files';
 export const runOverM3u = async ({ state, structure, playlistUrl, logLevel, }) => {
+    const tracksDone = state.m3u.getTrackDone(playlistUrl);
+    const hasAudioStreamToConsider = state.m3u.sampleSorter.hasAudioStreamToConsider(playlistUrl);
+    const hasVideoStreamToConsider = state.m3u.sampleSorter.hasVideoStreamToConsider(playlistUrl);
+    const audioDone = !hasAudioStreamToConsider && tracksDone;
+    const videoDone = !hasVideoStreamToConsider && tracksDone;
+    const bothDone = audioDone && videoDone;
+    if (bothDone) {
+        state.m3u.setAllChunksProcessed(playlistUrl);
+        return;
+    }
     const existingRun = state.m3u.getM3uStreamRun(playlistUrl);
     if (existingRun) {
         Log.trace(logLevel, 'Existing M3U parsing process found for', playlistUrl);
@@ -28,52 +38,56 @@ export const runOverM3u = async ({ state, structure, playlistUrl, logLevel, }) =
                     state.callbacks.tracks.setIsDone(state.logLevel);
                 }
             },
-            onAudioTrack: async (track) => {
-                const existingTracks = state.callbacks.tracks.getTracks();
-                let { trackId } = track;
-                while (existingTracks.find((t) => t.trackId === trackId)) {
-                    trackId++;
-                }
-                const onAudioSample = await registerAudioTrack({
-                    container: 'm3u8',
-                    state,
-                    track: {
-                        ...track,
-                        trackId,
-                    },
-                });
-                state.m3u.sampleSorter.addToStreamWithTrack(playlistUrl);
-                if (onAudioSample === null) {
-                    return null;
-                }
-                state.m3u.sampleSorter.addAudioStreamToConsider(playlistUrl, onAudioSample);
-                return async (sample) => {
-                    await state.m3u.sampleSorter.addAudioSample(playlistUrl, sample);
-                };
-            },
-            onVideoTrack: async (track) => {
-                const existingTracks = state.callbacks.tracks.getTracks();
-                let { trackId } = track;
-                while (existingTracks.find((t) => t.trackId === trackId)) {
-                    trackId++;
-                }
-                const onVideoSample = await registerVideoTrack({
-                    container: 'm3u8',
-                    state,
-                    track: {
-                        ...track,
-                        trackId,
-                    },
-                });
-                state.m3u.sampleSorter.addToStreamWithTrack(playlistUrl);
-                if (onVideoSample === null) {
-                    return null;
-                }
-                state.m3u.sampleSorter.addVideoStreamToConsider(playlistUrl, onVideoSample);
-                return async (sample) => {
-                    await state.m3u.sampleSorter.addVideoSample(playlistUrl, sample);
-                };
-            },
+            onAudioTrack: audioDone
+                ? null
+                : async (track) => {
+                    const existingTracks = state.callbacks.tracks.getTracks();
+                    let { trackId } = track;
+                    while (existingTracks.find((t) => t.trackId === trackId)) {
+                        trackId++;
+                    }
+                    const onAudioSample = await registerAudioTrack({
+                        container: 'm3u8',
+                        state,
+                        track: {
+                            ...track,
+                            trackId,
+                        },
+                    });
+                    state.m3u.sampleSorter.addToStreamWithTrack(playlistUrl);
+                    if (onAudioSample === null) {
+                        return null;
+                    }
+                    state.m3u.sampleSorter.addAudioStreamToConsider(playlistUrl, onAudioSample);
+                    return async (sample) => {
+                        await state.m3u.sampleSorter.addAudioSample(playlistUrl, sample);
+                    };
+                },
+            onVideoTrack: videoDone
+                ? null
+                : async (track) => {
+                    const existingTracks = state.callbacks.tracks.getTracks();
+                    let { trackId } = track;
+                    while (existingTracks.find((t) => t.trackId === trackId)) {
+                        trackId++;
+                    }
+                    const onVideoSample = await registerVideoTrack({
+                        container: 'm3u8',
+                        state,
+                        track: {
+                            ...track,
+                            trackId,
+                        },
+                    });
+                    state.m3u.sampleSorter.addToStreamWithTrack(playlistUrl);
+                    if (onVideoSample === null) {
+                        return null;
+                    }
+                    state.m3u.sampleSorter.addVideoStreamToConsider(playlistUrl, onVideoSample);
+                    return async (sample) => {
+                        await state.m3u.sampleSorter.addVideoSample(playlistUrl, sample);
+                    };
+                },
             m3uState: state.m3u,
             parentController: state.controller,
             readerInterface: state.readerInterface,

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

@@ -7,6 +7,8 @@ export declare const sampleSorter: ({ logLevel, getAllChunksProcessedForPlaylist
     addToStreamWithTrack: (src: string) => void;
     addVideoStreamToConsider: (src: string, callback: OnVideoSample) => void;
     addAudioStreamToConsider: (src: string, callback: OnAudioSample) => void;
+    hasAudioStreamToConsider: (src: string) => boolean;
+    hasVideoStreamToConsider: (src: string) => boolean;
     addAudioSample: (src: string, sample: AudioOrVideoSample) => Promise<void>;
     addVideoSample: (src: string, sample: AudioOrVideoSample) => Promise<void>;
     getNextStreamToRun: (streams: string[]) => string;

package/dist/containers/m3u/sample-sorter.js

@@ -14,6 +14,12 @@ export const sampleSorter = ({ logLevel, getAllChunksProcessedForPlaylist, }) =>
         addAudioStreamToConsider: (src, callback) => {
             audioCallbacks[src] = callback;
         },
+        hasAudioStreamToConsider: (src) => {
+            return Boolean(audioCallbacks[src]);
+        },
+        hasVideoStreamToConsider: (src) => {
+            return Boolean(videoCallbacks[src]);
+        },
         addAudioSample: async (src, sample) => {
             const callback = audioCallbacks[src];
             if (!callback) {
@@ -25,7 +31,7 @@ export const sampleSorter = ({ logLevel, getAllChunksProcessedForPlaylist, }) =>
         addVideoSample: async (src, sample) => {
             const callback = videoCallbacks[src];
             if (!callback) {
-                throw new Error('No callback found for audio sample');
+                throw new Error('No callback found for video sample.');
             }
             latestSample[src] = sample.dts;
             await callback(sample);
@@ -33,6 +39,9 @@ export const sampleSorter = ({ logLevel, getAllChunksProcessedForPlaylist, }) =>
         getNextStreamToRun: (streams) => {
             var _a, _b, _c;
             for (const stream of streams) {
+                if (getAllChunksProcessedForPlaylist(stream)) {
+                    continue;
+                }
                 // If a stream does not have a track yet, work on that
                 if (!streamsWithTracks.includes(stream)) {
                     Log.trace(logLevel, `Did not yet detect track of ${stream}, working on that`);
@@ -49,6 +58,9 @@ export const sampleSorter = ({ logLevel, getAllChunksProcessedForPlaylist, }) =>
                 }
             }
             for (const stream of streams) {
+                if (getAllChunksProcessedForPlaylist(stream)) {
+                    continue;
+                }
                 if (((_c = latestSample[stream]) !== null && _c !== void 0 ? _c : 0) === smallestDts) {
                     Log.trace(logLevel, `Working on ${stream} because it has the smallest DTS`);
                     return stream;

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

@@ -40,6 +40,9 @@ export type M3uDiscontinuitySequence = {
     type: 'm3u-discontinuity-sequence';
     value: number;
 };
+export type M3uIFrameStreamInfo = {
+    type: 'm3u-i-frame-stream-info';
+};
 export type M3uMap = {
     type: 'm3u-map';
     value: string;
@@ -69,7 +72,11 @@ export type M3uTextValue = {
     type: 'm3u-text-value';
     value: string;
 };
-export type M3uBox = M3uHeader | M3uPlaylist | M3uVersion | M3uIndependentSegments | M3uStreamInfo | M3uTargetDuration | M3uPlaylistType | M3uExtInf | M3uMedia | M3uMediaInfo | M3uEndList | M3uMediaSequence | M3uDiscontinuitySequence | M3uMap | M3uTextValue;
+export type M3uAllowCache = {
+    type: 'm3u-allow-cache';
+    allowsCache: boolean;
+};
+export type M3uBox = M3uHeader | M3uPlaylist | M3uVersion | M3uIndependentSegments | M3uStreamInfo | M3uTargetDuration | M3uPlaylistType | M3uExtInf | M3uMedia | M3uMediaInfo | M3uEndList | M3uMediaSequence | M3uDiscontinuitySequence | M3uMap | M3uIFrameStreamInfo | M3uTextValue | M3uAllowCache;
 export type M3uStructure = {
     type: 'm3u';
     boxes: M3uBox[];

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

@@ -1,4 +1,6 @@
 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 hasAllTracksFromTransportStream: (parserState: ParserState) => boolean;

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

@@ -1,15 +1,19 @@
 import { truthy } from '../../truthy';
 import { findProgramMapTableOrThrow } from './traversal';
+export const filterStreamsBySupportedTypes = (streams) => {
+    return streams.filter((stream) => stream.streamType === 27 || stream.streamType === 15);
+};
 export const getTracksFromTransportStream = (parserState) => {
     const structure = parserState.getTsStructure();
     const programMapTable = findProgramMapTableOrThrow(structure);
     const parserTracks = parserState.callbacks.tracks.getTracks();
-    const mapped = programMapTable.streams
+    const mapped = filterStreamsBySupportedTypes(programMapTable.streams)
         .map((stream) => {
         return parserTracks.find((track) => track.trackId === stream.pid);
     })
         .filter(truthy);
-    if (mapped.length !== programMapTable.streams.length) {
+    if (mapped.length !==
+        filterStreamsBySupportedTypes(programMapTable.streams).length) {
         throw new Error('Not all tracks found');
     }
     return {

package/dist/containers/transport-stream/parse-pmt.js

@@ -8,11 +8,12 @@ const parsePmtTable = ({ iterator, tableId, sectionLength, }) => {
     const sectionNumber = iterator.getBits(8);
     const lastSectionNumber = iterator.getBits(8);
     const tables = [];
+    iterator.getBits(3); // reserved
+    iterator.getBits(13); // PCR PID
+    iterator.getBits(4); // reserved
+    const programInfoLength = iterator.getBits(12);
+    iterator.getBits(programInfoLength * 8); // program descriptor
     for (let i = sectionNumber; i <= lastSectionNumber; i++) {
-        iterator.getBits(3); // reserved
-        iterator.getBits(13); // PCR PID
-        iterator.getBits(4); // reserved
-        const programInfoLength = iterator.getBits(12);
         const streams = [];
         while (true) {
             const streamType = iterator.getBits(8);
@@ -22,7 +23,6 @@ const parsePmtTable = ({ iterator, tableId, sectionLength, }) => {
             const esInfoLength = iterator.getBits(12);
             iterator.getBits(esInfoLength * 8);
             streams.push({ streamType, pid: elementaryPid });
-            iterator.getBits(programInfoLength * 8); // program descriptor
             const remaining = sectionLength - (iterator.counter.getOffset() - start);
             if (remaining <= 4) {
                 break;

package/dist/containers/transport-stream/process-stream-buffers.js

@@ -1,3 +1,4 @@
+import { filterStreamsBySupportedTypes } from './get-tracks';
 import { handleAacPacket } from './handle-aac-packet';
 import { handleAvcPacket } from './handle-avc-packet';
 import { findProgramMapTableOrThrow, getStreamForId } from './traversal';
@@ -27,7 +28,7 @@ export const processStreamBuffer = async ({ streamBuffer, state, programId, stru
     if (!state.callbacks.tracks.hasAllTracks()) {
         const tracksRegistered = state.callbacks.tracks.getTracks().length;
         const { streams } = findProgramMapTableOrThrow(structure);
-        if (streams.length === tracksRegistered) {
+        if (filterStreamsBySupportedTypes(streams).length === tracksRegistered) {
             state.callbacks.tracks.setIsDone(state.logLevel);
         }
     }