@remotion/media-parser 4.0.285 → 4.0.286

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

@@ -1,17 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseWebm = void 0;
+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");
 // Parsing according to https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/
 const parseWebm = async (state) => {
     const structure = state.structure.getMatroskaStructure();
     const { iterator } = state;
+    const offset = iterator.counter.getOffset();
     const isInsideSegment = state.webm.isInsideSegment(iterator);
-    const isInsideCluster = state.webm.isInsideCluster(iterator);
+    const isInsideCluster = state.webm.isInsideCluster(offset);
     const results = await (0, segments_1.expectSegment)({
-        state,
+        iterator,
+        logLevel: state.logLevel,
+        statesForProcessing: (0, state_for_processing_1.selectStatesForProcessing)(state),
         isInsideSegment,
+        mediaSectionState: state.mediaSection,
     });
+    if ((results === null || results === void 0 ? void 0 : results.type) === 'SeekHead') {
+        const position = (0, get_byte_for_cues_1.getByteForSeek)({ seekHeadSegment: results, offset });
+        if (position !== null) {
+            state.webm.cues.triggerLoad(position, offset);
+        }
+    }
     if (results === null) {
         return null;
     }

package/dist/containers/webm/seek/fetch-web-cues.d.ts

@@ -0,0 +1,12 @@
+import type { MediaParserController } from '../../../controller/media-parser-controller';
+import type { LogLevel } from '../../../log';
+import type { ParseMediaSrc } from '../../../options';
+import type { ReaderInterface } from '../../../readers/reader';
+import type { MatroskaCue } from './format-cues';
+export declare const fetchWebmCues: ({ src, readerInterface, controller, position, logLevel, }: {
+    src: ParseMediaSrc;
+    readerInterface: ReaderInterface;
+    controller: MediaParserController;
+    position: number;
+    logLevel: LogLevel;
+}) => Promise<MatroskaCue[] | null>;

package/dist/containers/webm/seek/fetch-web-cues.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchWebmCues = void 0;
+const buffer_iterator_1 = require("../../../iterator/buffer-iterator");
+const segments_1 = require("../segments");
+const format_cues_1 = require("./format-cues");
+const fetchWebmCues = async ({ src, readerInterface, controller, position, logLevel, }) => {
+    const result = await readerInterface.read({
+        controller,
+        range: position,
+        src,
+    });
+    const { value } = await result.reader.reader.read();
+    if (!value) {
+        return null;
+    }
+    result.reader.abort();
+    const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(value, value.length);
+    const segment = await (0, segments_1.expectSegment)({
+        iterator,
+        logLevel,
+        statesForProcessing: null,
+        isInsideSegment: null,
+        mediaSectionState: null,
+    });
+    iterator.destroy();
+    if (!(segment === null || segment === void 0 ? void 0 : segment.value)) {
+        return null;
+    }
+    return (0, format_cues_1.formatCues)(segment.value);
+};
+exports.fetchWebmCues = fetchWebmCues;

package/dist/containers/webm/seek/format-cues.d.ts

@@ -0,0 +1,8 @@
+import type { PossibleEbml } from '../segments/all-segments';
+export type MatroskaCue = {
+    trackId: number;
+    timeInTimescale: number;
+    clusterPositionInSegment: number;
+    relativePosition: number;
+};
+export declare const formatCues: (cues: PossibleEbml[]) => MatroskaCue[];

package/dist/containers/webm/seek/format-cues.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCues = void 0;
+const formatCues = (cues) => {
+    var _a;
+    const matroskaCues = [];
+    for (const cue of cues) {
+        if (cue.type === 'Crc32') {
+            continue;
+        }
+        if (cue.type !== 'CuePoint') {
+            throw new Error('Expected CuePoint');
+        }
+        const cueTime = cue.value.find((_cue) => _cue.type === 'CueTime');
+        if (!cueTime) {
+            throw new Error('Expected CueTime');
+        }
+        const cueTrackPositions = cue.value.find((c) => c.type === 'CueTrackPositions');
+        if (!cueTrackPositions) {
+            throw new Error('Expected CueTrackPositions');
+        }
+        const cueTimeValue = cueTime.value.value;
+        const cueTrack = cueTrackPositions.value.find((_c) => _c.type === 'CueTrack');
+        if (!cueTrack) {
+            throw new Error('Expected CueTrack');
+        }
+        const cueClusterPosition = cueTrackPositions.value.find((_c) => _c.type === 'CueClusterPosition');
+        if (!cueClusterPosition) {
+            throw new Error('Expected CueClusterPosition');
+        }
+        const cueRelativePosition = cueTrackPositions.value.find((_c) => _c.type === 'CueRelativePosition');
+        const matroskaCue = {
+            trackId: cueTrack.value.value,
+            timeInTimescale: cueTimeValue,
+            clusterPositionInSegment: cueClusterPosition.value.value,
+            relativePosition: (_a = cueRelativePosition === null || cueRelativePosition === void 0 ? void 0 : cueRelativePosition.value.value) !== null && _a !== void 0 ? _a : 0,
+        };
+        matroskaCues.push(matroskaCue);
+    }
+    return matroskaCues;
+};
+exports.formatCues = formatCues;

package/dist/containers/webm/seek/get-seeking-byte.d.ts

@@ -0,0 +1,14 @@
+import type { LogLevel } from '../../../log';
+import type { WebmSeekingInfo } from '../../../seeking-info';
+import type { KeyframesState } from '../../../state/keyframes';
+import type { WebmState } from '../../../state/matroska/webm';
+import type { MediaSectionState } from '../../../state/video-section';
+import type { SeekResolution } from '../../../work-on-seek-request';
+export declare const getSeekingByteFromMatroska: ({ time, webmState, info, logLevel, mediaSection, keyframes, }: {
+    time: number;
+    webmState: WebmState;
+    info: WebmSeekingInfo;
+    logLevel: LogLevel;
+    mediaSection: MediaSectionState;
+    keyframes: KeyframesState;
+}) => Promise<SeekResolution>;

package/dist/containers/webm/seek/get-seeking-byte.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSeekingByteFromMatroska = void 0;
+const log_1 = require("../../../log");
+const toSeconds = (timeInTimescale, track) => {
+    return (timeInTimescale / track.timescale) * 1000;
+};
+const findBiggestCueBeforeTime = ({ cues, time, track, }) => {
+    let biggestCueBeforeTime;
+    for (const cue of cues) {
+        const cueTimeInSeconds = toSeconds(cue.timeInTimescale, track);
+        if (cueTimeInSeconds < time &&
+            (!biggestCueBeforeTime ||
+                cueTimeInSeconds >
+                    toSeconds(biggestCueBeforeTime.timeInTimescale, track))) {
+            biggestCueBeforeTime = cue;
+        }
+    }
+    return biggestCueBeforeTime;
+};
+const findKeyframeBeforeTime = ({ keyframes, time, }) => {
+    var _a;
+    let keyframeBeforeTime;
+    for (const keyframe of keyframes) {
+        if (keyframe.decodingTimeInSeconds < time &&
+            (!keyframeBeforeTime ||
+                keyframe.decodingTimeInSeconds >
+                    keyframeBeforeTime.decodingTimeInSeconds)) {
+            keyframeBeforeTime = keyframe;
+        }
+    }
+    return (_a = keyframeBeforeTime === null || keyframeBeforeTime === void 0 ? void 0 : keyframeBeforeTime.positionInBytes) !== null && _a !== void 0 ? _a : null;
+};
+const getByteFromCues = ({ cuesResponse, time, info, logLevel, }) => {
+    if (!cuesResponse) {
+        log_1.Log.trace(logLevel, 'Has no Matroska cues at the moment, cannot use them');
+        return null;
+    }
+    const { cues, segmentOffset } = cuesResponse;
+    log_1.Log.trace(logLevel, 'Has Matroska cues. Will use them to perform a seek.');
+    const biggestCueBeforeTime = findBiggestCueBeforeTime({
+        cues,
+        time,
+        track: info.track,
+    });
+    if (!biggestCueBeforeTime) {
+        return null;
+    }
+    return biggestCueBeforeTime.clusterPositionInSegment + segmentOffset;
+};
+const getSeekingByteFromMatroska = async ({ time, webmState, info, logLevel, mediaSection, keyframes, }) => {
+    var _a, _b;
+    if (!info.track) {
+        log_1.Log.trace(logLevel, 'No video track found, cannot seek yet');
+        return {
+            type: 'valid-but-must-wait',
+        };
+    }
+    const cuesResponse = (await webmState.cues.getLoadedCues());
+    // Check if we have already read keyframes
+    const byteFromObservedKeyframe = findKeyframeBeforeTime({
+        keyframes: keyframes.getKeyframes(),
+        time,
+    });
+    // Check if we have `Cues`
+    const byteFromCues = getByteFromCues({
+        cuesResponse,
+        time,
+        info,
+        logLevel,
+    });
+    // Fallback: back to the beginning
+    const byteFromFirstMediaSection = (_b = (_a = webmState.getFirstCluster()) === null || _a === void 0 ? void 0 : _a.start) !== null && _b !== void 0 ? _b : null;
+    // Optimization possibility for later:
+    // Don't seek back, if the last seen time is smaller than the time we want to seek to
+    const seekPossibilities = [
+        byteFromCues,
+        byteFromObservedKeyframe,
+        byteFromFirstMediaSection,
+    ].filter((n) => n !== null);
+    const byteToSeekTo = seekPossibilities.length === 0 ? null : Math.max(...seekPossibilities);
+    if (byteToSeekTo === null) {
+        // dont know what to do
+        return {
+            type: 'invalid',
+        };
+    }
+    // we have assured this is in a media section, but it might not be marked yet
+    // setting size because there is deduplication and media sections which are encompassed
+    // by others will get deleted
+    mediaSection.addMediaSection({
+        start: byteToSeekTo,
+        size: 1,
+    });
+    return {
+        type: 'do-seek',
+        byte: byteToSeekTo,
+    };
+};
+exports.getSeekingByteFromMatroska = getSeekingByteFromMatroska;

package/dist/containers/webm/seek/get-seeking-info.d.ts

@@ -0,0 +1,3 @@
+import type { WebmSeekingInfo } from '../../../seeking-info';
+import type { TracksState } from '../../../state/has-tracks-section';
+export declare const getSeekingInfoFromMatroska: (tracksState: TracksState) => WebmSeekingInfo;

package/dist/containers/webm/seek/get-seeking-info.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSeekingInfoFromMatroska = void 0;
+const getSeekingInfoFromMatroska = (tracksState) => {
+    const tracks = tracksState.getTracks();
+    const firstVideoTrack = tracks.find((track) => track.type === 'video');
+    return {
+        type: 'webm-seeking-info',
+        track: firstVideoTrack
+            ? {
+                timescale: firstVideoTrack.timescale,
+                trackId: firstVideoTrack.trackId,
+            }
+            : null,
+    };
+};
+exports.getSeekingInfoFromMatroska = getSeekingInfoFromMatroska;

package/dist/containers/webm/segments/all-segments.d.ts

@@ -371,6 +371,7 @@ export declare const seekHead: {
     readonly name: "SeekHead";
     readonly type: "children";
 };
+export type SeekHeadSegment = EbmlParsed<typeof seekHead>;
 export declare const voidHeader: {
     readonly name: "Void";
     readonly type: "uint8array";

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

@@ -1,9 +1,15 @@
-import type { ParserState } from '../../state/parser-state';
-import type { SegmentSection } from '../../state/webm';
+import type { BufferIterator } from '../../iterator/buffer-iterator';
+import type { LogLevel } from '../../log';
+import type { SegmentSection } from '../../state/matroska/webm';
+import type { MediaSectionState } from '../../state/video-section';
 import { type PossibleEbml, type TrackEntry } from './segments/all-segments';
+import { type WebmRequiredStatesForProcessing } from './state-for-processing';
 export type MatroskaSegment = PossibleEbml;
 export type OnTrackEntrySegment = (trackEntry: TrackEntry) => void;
-export declare const expectSegment: ({ state, isInsideSegment, }: {
-    state: ParserState;
+export declare const expectSegment: ({ statesForProcessing, isInsideSegment, iterator, logLevel, mediaSectionState, }: {
+    iterator: BufferIterator;
+    logLevel: LogLevel;
+    statesForProcessing: WebmRequiredStatesForProcessing | null;
     isInsideSegment: SegmentSection | null;
+    mediaSectionState: MediaSectionState | null;
 }) => Promise<MatroskaSegment | null>;

package/dist/containers/webm/segments.js

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectSegment = void 0;
-/* eslint-disable @typescript-eslint/no-use-before-define */
 const log_1 = require("../../log");
 const parse_ebml_1 = require("./parse-ebml");
 const all_segments_1 = require("./segments/all-segments");
-const expectSegment = async ({ state, isInsideSegment, }) => {
+const expectSegment = async ({ statesForProcessing, isInsideSegment, iterator, logLevel, mediaSectionState, }) => {
     var _a;
-    const { iterator } = state;
     if (iterator.bytesRemaining() === 0) {
         throw new Error('has no bytes');
     }
@@ -26,9 +24,12 @@ const expectSegment = async ({ state, isInsideSegment, }) => {
         return null;
     }
     const bytesRemainingNow = iterator.bytesRemaining();
-    log_1.Log.trace(state.logLevel, 'Segment ID:', (_a = all_segments_1.ebmlMap[segmentId]) === null || _a === void 0 ? void 0 : _a.name, 'Size:' + size, bytesRemainingNow);
+    log_1.Log.trace(logLevel, 'Segment ID:', (_a = all_segments_1.ebmlMap[segmentId]) === null || _a === void 0 ? void 0 : _a.name, 'Size:' + size, bytesRemainingNow);
     if (segmentId === all_segments_1.matroskaElements.Segment) {
-        state.webm.addSegment({
+        if (!statesForProcessing) {
+            throw new Error('States for processing are required');
+        }
+        statesForProcessing.webmState.addSegment({
             start: offset,
             size,
         });
@@ -43,7 +44,16 @@ const expectSegment = async ({ state, isInsideSegment, }) => {
         if (isInsideSegment === null) {
             throw new Error('Expected to be inside segment');
         }
-        state.webm.addCluster({
+        if (!statesForProcessing) {
+            throw new Error('States for processing are required');
+        }
+        if (mediaSectionState) {
+            mediaSectionState.addMediaSection({
+                start: offset,
+                size,
+            });
+        }
+        statesForProcessing.webmState.addCluster({
             start: offset,
             size,
             segment: isInsideSegment.index,
@@ -62,19 +72,27 @@ const expectSegment = async ({ state, isInsideSegment, }) => {
     const segment = await parseSegment({
         segmentId,
         length: size,
-        state,
         headerReadSoFar: iterator.counter.getOffset() - offset,
+        statesForProcessing,
+        iterator,
     });
     return segment;
 };
 exports.expectSegment = expectSegment;
-const parseSegment = async ({ segmentId, length, state, headerReadSoFar, }) => {
+const parseSegment = async ({ segmentId, length, iterator, headerReadSoFar, statesForProcessing, }) => {
     if (length < 0) {
         throw new Error(`Expected length of ${segmentId} to be greater or equal 0`);
     }
-    state.iterator.counter.decrement(headerReadSoFar);
-    const offset = state.iterator.counter.getOffset();
-    const ebml = await (0, parse_ebml_1.parseEbml)(state);
-    const remapped = await (0, parse_ebml_1.postprocessEbml)({ offset, ebml, state });
+    iterator.counter.decrement(headerReadSoFar);
+    const offset = iterator.counter.getOffset();
+    const ebml = await (0, parse_ebml_1.parseEbml)(iterator, statesForProcessing);
+    if (!statesForProcessing) {
+        return ebml;
+    }
+    const remapped = await (0, parse_ebml_1.postprocessEbml)({
+        offset,
+        ebml,
+        statesForProcessing,
+    });
     return remapped;
 };

package/dist/containers/webm/state-for-processing.d.ts

@@ -0,0 +1,15 @@
+import type { LogLevel } from '../../log';
+import type { WebmState } from '../../state/matroska/webm';
+import type { ParserState } from '../../state/parser-state';
+import type { SampleCallbacks } from '../../state/sample-callbacks';
+import type { StructureState } from '../../state/structure';
+import type { OnAudioTrack, OnVideoTrack } from '../../webcodec-sample-types';
+export type WebmRequiredStatesForProcessing = {
+    webmState: WebmState;
+    callbacks: SampleCallbacks;
+    logLevel: LogLevel;
+    onAudioTrack: OnAudioTrack | null;
+    onVideoTrack: OnVideoTrack | null;
+    structureState: StructureState;
+};
+export declare const selectStatesForProcessing: ({ callbacks, logLevel, onAudioTrack, onVideoTrack, structure, webm, }: ParserState) => WebmRequiredStatesForProcessing;

package/dist/containers/webm/state-for-processing.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectStatesForProcessing = void 0;
+const selectStatesForProcessing = ({ callbacks, logLevel, onAudioTrack, onVideoTrack, structure, webm, }) => {
+    return {
+        webmState: webm,
+        callbacks,
+        logLevel,
+        onAudioTrack,
+        onVideoTrack,
+        structureState: structure,
+    };
+};
+exports.selectStatesForProcessing = selectStatesForProcessing;

package/dist/controller/seek-signal.d.ts

@@ -7,8 +7,8 @@ export type SeekSignal = {
     };
 };
 type SeekToTime = {
-    type: 'keyframe-before-time-in-seconds';
-    time: number;
+    type: 'keyframe-before-time';
+    timeInSeconds: number;
 };
 type SeekToByte = {
     type: 'byte';

package/dist/download-and-parse-media.js

@@ -6,7 +6,7 @@ const internal_parse_media_1 = require("./internal-parse-media");
 const log_1 = require("./log");
 const web_1 = require("./web");
 const downloadAndParseMedia = async (options) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15;
     const logLevel = (_a = options.logLevel) !== null && _a !== void 0 ? _a : 'info';
     const content = await options.writer.createContent({
         filename: 'hmm',
@@ -70,6 +70,7 @@ const downloadAndParseMedia = async (options) => {
         },
         acknowledgeRemotionLicense: Boolean(options.acknowledgeRemotionLicense),
         apiName: 'parseAndDownloadMedia()',
+        makeSamplesStartAtZero: (_15 = options.makeSamplesStartAtZero) !== null && _15 !== void 0 ? _15 : true,
     });
     await content.finish();
     return returnValue;

package/dist/emit-audio-sample.d.ts

@@ -1,15 +1,12 @@
 import type { SampleCallbacks } from './state/sample-callbacks';
 import type { AudioOrVideoSample } from './webcodec-sample-types';
-import type { WorkOnSeekRequestOptions } from './work-on-seek-request';
-export declare const emitAudioSample: ({ trackId, audioSample, workOnSeekRequestOptions, callbacks, }: {
+export declare const emitAudioSample: ({ trackId, audioSample, callbacks, }: {
     trackId: number;
     audioSample: AudioOrVideoSample;
-    workOnSeekRequestOptions: WorkOnSeekRequestOptions;
     callbacks: SampleCallbacks;
 }) => Promise<void>;
-export declare const emitVideoSample: ({ trackId, videoSample, workOnSeekRequestOptions, callbacks, }: {
+export declare const emitVideoSample: ({ trackId, videoSample, callbacks, }: {
     trackId: number;
     videoSample: AudioOrVideoSample;
-    workOnSeekRequestOptions: WorkOnSeekRequestOptions;
     callbacks: SampleCallbacks;
 }) => Promise<void>;

package/dist/emit-audio-sample.js

@@ -1,14 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.emitVideoSample = exports.emitAudioSample = void 0;
-const work_on_seek_request_1 = require("./work-on-seek-request");
-const emitAudioSample = async ({ trackId, audioSample, workOnSeekRequestOptions, callbacks, }) => {
+const emitAudioSample = async ({ trackId, audioSample, callbacks, }) => {
     await callbacks.onAudioSample(trackId, audioSample);
-    await (0, work_on_seek_request_1.workOnSeekRequest)(workOnSeekRequestOptions);
 };
 exports.emitAudioSample = emitAudioSample;
-const emitVideoSample = async ({ trackId, videoSample, workOnSeekRequestOptions, callbacks, }) => {
+const emitVideoSample = async ({ trackId, videoSample, callbacks, }) => {
     await callbacks.onVideoSample(trackId, videoSample);
-    await (0, work_on_seek_request_1.workOnSeekRequest)(workOnSeekRequestOptions);
 };
 exports.emitVideoSample = emitVideoSample;