@remotion/media-parser 4.0.241 → 4.0.242

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

@@ -4,7 +4,7 @@ exports.getSampleFromBlock = void 0;
 const buffer_iterator_1 = require("../../buffer-iterator");
 const all_segments_1 = require("./segments/all-segments");
 const block_simple_block_flags_1 = require("./segments/block-simple-block-flags");
-const getSampleFromBlock = (ebml, parserContext, offset) => {
+const getSampleFromBlock = (ebml, state, offset) => {
     const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(ebml.value, ebml.value.length);
     const trackNumber = iterator.getVint();
     if (trackNumber === null) {
@@ -14,9 +14,9 @@ const getSampleFromBlock = (ebml, parserContext, offset) => {
     const { keyframe } = (0, block_simple_block_flags_1.parseBlockFlags)(iterator, ebml.type === 'SimpleBlock'
         ? all_segments_1.matroskaElements.SimpleBlock
         : all_segments_1.matroskaElements.Block);
-    const { codec, trackTimescale } = parserContext.parserState.getTrackInfoByNumber(trackNumber);
-    const clusterOffset = parserContext.parserState.getTimestampOffsetForByteOffset(offset);
-    const timescale = parserContext.parserState.getTimescale();
+    const { codec, trackTimescale } = state.webm.getTrackInfoByNumber(trackNumber);
+    const clusterOffset = state.webm.getTimestampOffsetForByteOffset(offset);
+    const timescale = state.webm.getTimescale();
     if (clusterOffset === undefined) {
         throw new Error('Could not find offset for byte offset ' + offset);
     }
@@ -39,6 +39,8 @@ const getSampleFromBlock = (ebml, parserContext, offset) => {
             duration: undefined,
             trackId: trackNumber,
             timestamp: timecodeInMicroseconds,
+            offset,
+            timescale,
         };
         if (keyframe === null) {
             iterator.destroy();
@@ -66,6 +68,8 @@ const getSampleFromBlock = (ebml, parserContext, offset) => {
             duration: undefined,
             cts: timecodeInMicroseconds,
             dts: timecodeInMicroseconds,
+            offset,
+            timescale,
         };
         iterator.destroy();
         return {

package/dist/boxes/webm/parse-ebml.d.ts

@@ -1,12 +1,12 @@
 import { type BufferIterator } from '../../buffer-iterator';
-import type { ParserContext } from '../../parser-context';
+import type { ParserState } from '../../state/parser-state';
 import type { PossibleEbml } from './segments/all-segments';
 export type Prettify<T> = {
     [K in keyof T]: T[K];
 } & {};
-export declare const parseEbml: (iterator: BufferIterator, parserContext: ParserContext) => Promise<Prettify<PossibleEbml>>;
-export declare const postprocessEbml: ({ offset, ebml, parserContext, }: {
+export declare const parseEbml: (iterator: BufferIterator, state: ParserState) => Promise<Prettify<PossibleEbml>>;
+export declare const postprocessEbml: ({ offset, ebml, state, }: {
     offset: number;
     ebml: Prettify<PossibleEbml>;
-    parserContext: ParserContext;
+    state: ParserState;
 }) => Promise<Prettify<PossibleEbml>>;

package/dist/boxes/webm/parse-ebml.js

@@ -5,7 +5,7 @@ const register_track_1 = require("../../register-track");
 const get_sample_from_block_1 = require("./get-sample-from-block");
 const make_track_1 = require("./make-track");
 const all_segments_1 = require("./segments/all-segments");
-const parseEbml = async (iterator, parserContext) => {
+const parseEbml = async (iterator, state) => {
     const hex = iterator.getMatroskaSegmentId();
     if (hex === null) {
         throw new Error('Not enough bytes left to parse EBML - this should not happen');
@@ -83,12 +83,12 @@ const parseEbml = async (iterator, parserContext) => {
                 break;
             }
             const offset = iterator.counter.getOffset();
-            const value = await (0, exports.parseEbml)(iterator, parserContext);
+            const value = await (0, exports.parseEbml)(iterator, state);
             // eslint-disable-next-line @typescript-eslint/no-use-before-define
             const remapped = await (0, exports.postprocessEbml)({
                 offset,
                 ebml: value,
-                parserContext,
+                state,
             });
             children.push(remapped);
             const offsetNow = iterator.counter.getOffset();
@@ -105,46 +105,46 @@ const parseEbml = async (iterator, parserContext) => {
     throw new Error(`Unknown segment type ${hasInMap.type}`);
 };
 exports.parseEbml = parseEbml;
-const postprocessEbml = async ({ offset, ebml, parserContext, }) => {
+const postprocessEbml = async ({ offset, ebml, state, }) => {
     if (ebml.type === 'TimestampScale') {
-        parserContext.parserState.setTimescale(ebml.value.value);
+        state.webm.setTimescale(ebml.value.value);
     }
     if (ebml.type === 'TrackEntry') {
-        parserContext.parserState.onTrackEntrySegment(ebml);
+        state.webm.onTrackEntrySegment(ebml);
         const track = (0, make_track_1.getTrack)({
             track: ebml,
-            timescale: parserContext.parserState.getTimescale(),
+            timescale: state.webm.getTimescale(),
         });
         if (track) {
             await (0, register_track_1.registerTrack)({
-                options: parserContext,
+                state,
                 track,
                 container: 'webm',
             });
         }
     }
     if (ebml.type === 'Timestamp') {
-        parserContext.parserState.setTimestampOffset(offset, ebml.value.value);
+        state.webm.setTimestampOffset(offset, ebml.value.value);
     }
     if (ebml.type === 'Block' || ebml.type === 'SimpleBlock') {
-        const sample = (0, get_sample_from_block_1.getSampleFromBlock)(ebml, parserContext, offset);
-        if (sample.type === 'video-sample' && parserContext.nullifySamples) {
-            await parserContext.parserState.onVideoSample(sample.videoSample.trackId, sample.videoSample);
+        const sample = (0, get_sample_from_block_1.getSampleFromBlock)(ebml, state, offset);
+        if (sample.type === 'video-sample' && state.nullifySamples) {
+            await state.callbacks.onVideoSample(sample.videoSample.trackId, sample.videoSample);
             return {
                 type: 'Block',
                 value: new Uint8Array([]),
                 minVintWidth: ebml.minVintWidth,
             };
         }
-        if (sample.type === 'audio-sample' && parserContext.nullifySamples) {
-            await parserContext.parserState.onAudioSample(sample.audioSample.trackId, sample.audioSample);
+        if (sample.type === 'audio-sample' && state.nullifySamples) {
+            await state.callbacks.onAudioSample(sample.audioSample.trackId, sample.audioSample);
             return {
                 type: 'Block',
                 value: new Uint8Array([]),
                 minVintWidth: ebml.minVintWidth,
             };
         }
-        if (sample.type === 'no-sample' && parserContext.nullifySamples) {
+        if (sample.type === 'no-sample' && state.nullifySamples) {
             return {
                 type: 'Block',
                 value: new Uint8Array([]),
@@ -164,15 +164,15 @@ const postprocessEbml = async ({ offset, ebml, parserContext, }) => {
         const hasReferenceBlock = ebml.value.find((c) => c.type === 'ReferenceBlock');
         const sample = block.value.length === 0
             ? null
-            : (0, get_sample_from_block_1.getSampleFromBlock)(block, parserContext, offset);
+            : (0, get_sample_from_block_1.getSampleFromBlock)(block, state, offset);
         if (sample && sample.type === 'partial-video-sample') {
             const completeFrame = {
                 ...sample.partialVideoSample,
                 type: hasReferenceBlock ? 'delta' : 'key',
             };
-            await parserContext.parserState.onVideoSample(sample.partialVideoSample.trackId, completeFrame);
+            await state.callbacks.onVideoSample(sample.partialVideoSample.trackId, completeFrame);
         }
-        if (parserContext.nullifySamples) {
+        if (state.nullifySamples) {
             return {
                 type: 'BlockGroup',
                 value: [],

package/dist/boxes/webm/parse-webm-header.d.ts

@@ -1,9 +1,9 @@
 import type { BufferIterator } from '../../buffer-iterator';
 import type { Options, ParseMediaFields } from '../../options';
-import type { MatroskaStructure, ParseResult } from '../../parse-result';
-import type { ParserContext } from '../../parser-context';
-export declare const parseWebm: ({ counter, parserContext, fields, }: {
+import type { ParseResult } from '../../parse-result';
+import type { ParserState } from '../../state/parser-state';
+export declare const parseWebm: ({ counter, state, fields, }: {
     counter: BufferIterator;
-    parserContext: ParserContext;
+    state: ParserState;
     fields: Options<ParseMediaFields>;
-}) => Promise<ParseResult<MatroskaStructure>>;
+}) => Promise<ParseResult>;

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

@@ -6,12 +6,10 @@ const continueAfterMatroskaResult = (result, structure) => {
     if (result.status === 'done') {
         return {
             status: 'done',
-            segments: structure,
         };
     }
     return {
         status: 'incomplete',
-        segments: structure,
         continueParsing: async () => {
             const newResult = await result.continueParsing();
             return continueAfterMatroskaResult(newResult, structure);
@@ -20,13 +18,16 @@ const continueAfterMatroskaResult = (result, structure) => {
     };
 };
 // Parsing according to https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/
-const parseWebm = async ({ counter, parserContext, fields, }) => {
-    const structure = { type: 'matroska', boxes: [] };
+const parseWebm = async ({ counter, state, fields, }) => {
+    const structure = state.structure.getStructure();
+    if (structure.type !== 'matroska') {
+        throw new Error('Invalid structure type');
+    }
     const results = await (0, parse_children_1.expectChildren)({
         iterator: counter,
         length: Infinity,
         children: structure.boxes,
-        parserContext,
+        state,
         startOffset: counter.counter.getOffset(),
         fields,
         topLevelStructure: structure,

package/dist/boxes/webm/segments/parse-children.d.ts

@@ -1,22 +1,22 @@
 import type { BufferIterator } from '../../../buffer-iterator';
 import type { Options, ParseMediaFields } from '../../../options';
 import type { ExpectSegmentParseResult, MatroskaParseResult, MatroskaStructure } from '../../../parse-result';
-import type { ParserContext } from '../../../parser-context';
+import type { ParserState } from '../../../state/parser-state';
 import type { MatroskaSegment } from '../segments';
 import type { PossibleEbml } from './all-segments';
-export declare const expectAndProcessSegment: ({ iterator, parserContext, offset, children, fields, topLevelStructure, }: {
+export declare const expectAndProcessSegment: ({ iterator, state, offset, children, fields, topLevelStructure, }: {
     iterator: BufferIterator;
-    parserContext: ParserContext;
+    state: ParserState;
     offset: number;
     children: PossibleEbml[];
     fields: Options<ParseMediaFields>;
     topLevelStructure: MatroskaStructure;
 }) => Promise<ExpectSegmentParseResult>;
-export declare const expectChildren: ({ iterator, length, children, parserContext, startOffset, fields, topLevelStructure, }: {
+export declare const expectChildren: ({ iterator, length, children, state, startOffset, fields, topLevelStructure, }: {
     iterator: BufferIterator;
     length: number;
     children: MatroskaSegment[];
-    parserContext: ParserContext;
+    state: ParserState;
     startOffset: number;
     fields: Options<ParseMediaFields>;
     topLevelStructure: MatroskaStructure;

package/dist/boxes/webm/segments/parse-children.js

@@ -6,14 +6,14 @@ const segments_1 = require("../segments");
 const processParseResult = ({ parseResult, children, state, fields, topLevelStructure, }) => {
     if (parseResult.segment && !children.includes(parseResult.segment)) {
         children.push(parseResult.segment);
-        if ((0, has_all_info_1.hasAllInfo)({ fields, state, structure: topLevelStructure })) {
+        if ((0, has_all_info_1.hasAllInfo)({ fields, state })) {
             return {
                 status: 'done',
                 segment: parseResult.segment,
             };
         }
         if (parseResult.segment.type === 'Tracks') {
-            state.tracks.setIsDone();
+            state.callbacks.tracks.setIsDone();
         }
     }
     if (parseResult.status === 'incomplete') {
@@ -38,10 +38,10 @@ const processParseResult = ({ parseResult, children, state, fields, topLevelStru
         segment: parseResult.segment,
     };
 };
-const expectAndProcessSegment = async ({ iterator, parserContext, offset, children, fields, topLevelStructure, }) => {
+const expectAndProcessSegment = async ({ iterator, state, offset, children, fields, topLevelStructure, }) => {
     const segment = await (0, segments_1.expectSegment)({
         iterator,
-        parserContext,
+        state,
         offset,
         children,
         fields,
@@ -50,13 +50,13 @@ const expectAndProcessSegment = async ({ iterator, parserContext, offset, childr
     return processParseResult({
         children,
         parseResult: segment,
-        state: parserContext.parserState,
+        state,
         fields,
         topLevelStructure,
     });
 };
 exports.expectAndProcessSegment = expectAndProcessSegment;
-const continueAfterSegmentResult = async ({ result, length, children, parserContext, iterator, startOffset, fields, topLevelStructure, }) => {
+const continueAfterSegmentResult = async ({ result, length, children, state, iterator, startOffset, fields, topLevelStructure, }) => {
     if (result.status === 'done') {
         throw new Error('Should not continue after done');
     }
@@ -70,7 +70,7 @@ const continueAfterSegmentResult = async ({ result, length, children, parserCont
                     children,
                     iterator,
                     length,
-                    parserContext,
+                    state,
                     startOffset,
                     fields,
                     topLevelStructure,
@@ -87,7 +87,7 @@ const continueAfterSegmentResult = async ({ result, length, children, parserCont
                 children,
                 iterator,
                 length,
-                parserContext,
+                state,
                 startOffset,
                 fields,
                 topLevelStructure,
@@ -96,7 +96,7 @@ const continueAfterSegmentResult = async ({ result, length, children, parserCont
         skipTo: null,
     };
 };
-const expectChildren = async ({ iterator, length, children, parserContext, startOffset, fields, topLevelStructure, }) => {
+const expectChildren = async ({ iterator, length, children, state, startOffset, fields, topLevelStructure, }) => {
     while (iterator.counter.getOffset() < startOffset + length) {
         if (iterator.bytesRemaining() === 0) {
             break;
@@ -104,7 +104,7 @@ const expectChildren = async ({ iterator, length, children, parserContext, start
         const currentOffset = iterator.counter.getOffset();
         const child = await (0, exports.expectAndProcessSegment)({
             iterator,
-            parserContext,
+            state,
             offset: currentOffset,
             children,
             fields,
@@ -112,8 +112,7 @@ const expectChildren = async ({ iterator, length, children, parserContext, start
         });
         if ((0, has_all_info_1.hasAllInfo)({
             fields,
-            state: parserContext.parserState,
-            structure: topLevelStructure,
+            state,
         })) {
             return {
                 status: 'done',
@@ -128,7 +127,7 @@ const expectChildren = async ({ iterator, length, children, parserContext, start
                         children,
                         iterator,
                         length: length - (currentOffset - startOffset),
-                        parserContext,
+                        state,
                         startOffset: currentOffset,
                         fields,
                         topLevelStructure,

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

@@ -1,13 +1,13 @@
 import type { BufferIterator } from '../../buffer-iterator';
 import type { Options, ParseMediaFields } from '../../options';
 import type { ExpectSegmentParseResult, MatroskaStructure } from '../../parse-result';
-import type { ParserContext } from '../../parser-context';
+import type { ParserState } from '../../state/parser-state';
 import { type PossibleEbml, type TrackEntry } from './segments/all-segments';
 export type MatroskaSegment = PossibleEbml;
 export type OnTrackEntrySegment = (trackEntry: TrackEntry) => void;
-export declare const expectSegment: ({ iterator, parserContext, offset, children, fields, topLevelStructure, }: {
+export declare const expectSegment: ({ iterator, state, offset, children, fields, topLevelStructure, }: {
     iterator: BufferIterator;
-    parserContext: ParserContext;
+    state: ParserState;
     offset: number;
     children: PossibleEbml[];
     fields: Options<ParseMediaFields>;

package/dist/boxes/webm/segments.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectSegment = void 0;
 const parse_ebml_1 = require("./parse-ebml");
 const parse_children_1 = require("./segments/parse-children");
-const continueAfterMatroskaParseResult = async ({ result, iterator, parserContext, segment, }) => {
+const continueAfterMatroskaParseResult = async ({ result, iterator, state, segment, }) => {
     if (result.status === 'done') {
         throw new Error('Should not continue after done');
     }
@@ -19,7 +19,7 @@ const continueAfterMatroskaParseResult = async ({ result, iterator, parserContex
             return continueAfterMatroskaParseResult({
                 result: proceeded,
                 iterator,
-                parserContext,
+                state,
                 segment,
             });
         },
@@ -27,7 +27,7 @@ const continueAfterMatroskaParseResult = async ({ result, iterator, parserContex
         status: 'incomplete',
     };
 };
-const expectSegment = async ({ iterator, parserContext, offset, children, fields, topLevelStructure, }) => {
+const expectSegment = async ({ iterator, state, offset, children, fields, topLevelStructure, }) => {
     iterator.counter.decrement(iterator.counter.getOffset() - offset);
     if (iterator.bytesRemaining() === 0) {
         return {
@@ -35,7 +35,7 @@ const expectSegment = async ({ iterator, parserContext, offset, children, fields
             continueParsing: () => {
                 return (0, parse_children_1.expectAndProcessSegment)({
                     iterator,
-                    parserContext,
+                    state,
                     offset,
                     children,
                     fields,
@@ -53,7 +53,7 @@ const expectSegment = async ({ iterator, parserContext, offset, children, fields
             continueParsing: () => {
                 return (0, parse_children_1.expectAndProcessSegment)({
                     iterator,
-                    parserContext,
+                    state,
                     offset,
                     children,
                     fields,
@@ -73,7 +73,7 @@ const expectSegment = async ({ iterator, parserContext, offset, children, fields
             continueParsing: () => {
                 return (0, exports.expectSegment)({
                     iterator,
-                    parserContext,
+                    state,
                     offset,
                     children,
                     fields,
@@ -94,7 +94,7 @@ const expectSegment = async ({ iterator, parserContext, offset, children, fields
             iterator,
             length,
             children: newSegment.value,
-            parserContext,
+            state,
             startOffset: iterator.counter.getOffset(),
             fields,
             topLevelStructure,
@@ -105,7 +105,7 @@ const expectSegment = async ({ iterator, parserContext, offset, children, fields
                 continueParsing: () => {
                     return continueAfterMatroskaParseResult({
                         iterator,
-                        parserContext,
+                        state,
                         result: main,
                         segment: newSegment,
                     });
@@ -127,7 +127,7 @@ const expectSegment = async ({ iterator, parserContext, offset, children, fields
             continueParsing: () => {
                 return (0, exports.expectSegment)({
                     iterator,
-                    parserContext,
+                    state,
                     offset,
                     children,
                     fields,
@@ -140,7 +140,7 @@ const expectSegment = async ({ iterator, parserContext, offset, children, fields
         segmentId,
         iterator,
         length,
-        parserContext,
+        state,
         headerReadSoFar: iterator.counter.getOffset() - offset,
     });
     return {
@@ -149,13 +149,13 @@ const expectSegment = async ({ iterator, parserContext, offset, children, fields
     };
 };
 exports.expectSegment = expectSegment;
-const parseSegment = async ({ segmentId, iterator, length, parserContext, headerReadSoFar, }) => {
+const parseSegment = async ({ segmentId, iterator, length, state, headerReadSoFar, }) => {
     if (length < 0) {
         throw new Error(`Expected length of ${segmentId} to be greater or equal 0`);
     }
     iterator.counter.decrement(headerReadSoFar);
     const offset = iterator.counter.getOffset();
-    const ebml = await (0, parse_ebml_1.parseEbml)(iterator, parserContext);
-    const remapped = await (0, parse_ebml_1.postprocessEbml)({ offset, ebml, parserContext });
+    const ebml = await (0, parse_ebml_1.parseEbml)(iterator, state);
+    const remapped = await (0, parse_ebml_1.postprocessEbml)({ offset, ebml, state });
     return remapped;
 };

package/dist/convert-audio-or-video-sample.js

@@ -12,6 +12,8 @@ const convertAudioOrVideoSampleToWebCodecsTimestamps = (sample, timescale) => {
         data: sample.data,
         trackId: sample.trackId,
         type: sample.type,
+        offset: sample.offset,
+        timescale: 1000000,
     };
 };
 exports.convertAudioOrVideoSampleToWebCodecsTimestamps = convertAudioOrVideoSampleToWebCodecsTimestamps;

package/dist/emit-available-info.d.ts

@@ -1,12 +1,11 @@
-import type { AllOptions, AllParseMediaFields, Options, ParseMediaCallbacks, ParseMediaFields, ParseMediaResult } from './options';
-import type { ParseResult, Structure } from './parse-result';
+import type { AllParseMediaFields, Options, ParseMediaCallbacks, ParseMediaFields, ParseMediaResult } from './options';
+import type { ParseResult } from './parse-result';
 import type { ParserState } from './state/parser-state';
-export declare const emitAvailableInfo: ({ hasInfo, parseResult, callbacks, state, returnValue, contentLength, name, mimeType, fieldsInReturnValue, emittedFields, }: {
+export declare const emitAvailableInfo: ({ hasInfo, parseResult, callbacks, state, returnValue, contentLength, name, mimeType, fieldsInReturnValue, }: {
     hasInfo: Record<keyof Options<ParseMediaFields>, boolean>;
-    parseResult: ParseResult<Structure> | null;
+    parseResult: ParseResult | null;
     callbacks: ParseMediaCallbacks;
     fieldsInReturnValue: Options<ParseMediaFields>;
-    emittedFields: AllOptions<ParseMediaFields>;
     state: ParserState;
     returnValue: ParseMediaResult<AllParseMediaFields>;
     contentLength: number | null;