@remotion/media-parser 4.0.229 → 4.0.231

package/dist/boxes/iso-base-media/stsd/colr.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseColorParameterBox = void 0;
-const parseColorParameterBox = ({ iterator, }) => {
+const parse_icc_profile_1 = require("../parse-icc-profile");
+const parseColorParameterBox = ({ iterator, size, }) => {
     const byteString = iterator.getByteString(4);
     if (byteString === 'nclx') {
         const primaries = iterator.getUint16();
@@ -12,6 +13,7 @@ const parseColorParameterBox = ({ iterator, }) => {
         iterator.stopReadingBits();
         return {
             type: 'colr-box',
+            colorType: 'transfer-characteristics',
             fullRangeFlag,
             matrixIndex,
             primaries,
@@ -24,12 +26,22 @@ const parseColorParameterBox = ({ iterator, }) => {
         const matrixIndex = iterator.getUint16();
         return {
             type: 'colr-box',
+            colorType: 'transfer-characteristics',
             fullRangeFlag: false,
             matrixIndex,
             primaries,
             transfer,
         };
     }
+    if (byteString === 'prof') {
+        const profile = iterator.getSlice(size - 12);
+        return {
+            type: 'colr-box',
+            colorType: 'icc-profile',
+            profile,
+            parsed: (0, parse_icc_profile_1.parseIccProfile)(profile),
+        };
+    }
     throw new Error('Unexpected box type ' + byteString);
 };
 exports.parseColorParameterBox = parseColorParameterBox;

package/dist/boxes/iso-base-media/stsd/mebx.d.ts

@@ -8,11 +8,10 @@ export interface MebxBox extends BaseBox {
     format: string;
     children: AnySegment[];
 }
-export declare const parseMebx: ({ iterator, offset, size, options, littleEndian, signal, }: {
+export declare const parseMebx: ({ iterator, offset, size, options, signal, }: {
     iterator: BufferIterator;
     offset: number;
     size: number;
     options: ParserContext;
-    littleEndian: boolean;
     signal: AbortSignal | null;
 }) => Promise<MebxBox>;

package/dist/boxes/iso-base-media/stsd/mebx.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMebx = void 0;
 const process_box_1 = require("../process-box");
-const parseMebx = async ({ iterator, offset, size, options, littleEndian, signal, }) => {
+const parseMebx = async ({ iterator, offset, size, options, signal, }) => {
     // reserved, 6 bit
     iterator.discard(6);
     const dataReferenceIndex = iterator.getUint16();
@@ -13,8 +13,8 @@ const parseMebx = async ({ iterator, offset, size, options, littleEndian, signal
         initialBoxes: [],
         options,
         continueMdat: false,
-        littleEndian,
         signal,
+        logLevel: 'info',
     });
     if (children.status === 'incomplete') {
         throw new Error('Incomplete boxes are not allowed');

package/dist/boxes/iso-base-media/stsd/samples.d.ts

@@ -1,4 +1,5 @@
 import type { BufferIterator } from '../../../buffer-iterator';
+import type { LogLevel } from '../../../log';
 import type { AnySegment } from '../../../parse-result';
 import type { ParserContext } from '../../../parser-context';
 type SampleBase = {
@@ -48,15 +49,17 @@ export type Sample = AudioSample | VideoSample | UnknownSample;
 type SampleAndNext = {
     sample: Sample | null;
 };
-export declare const processSample: ({ iterator, options, signal, }: {
+export declare const processSample: ({ iterator, options, signal, logLevel, }: {
     iterator: BufferIterator;
     options: ParserContext;
     signal: AbortSignal | null;
+    logLevel: LogLevel;
 }) => Promise<SampleAndNext>;
-export declare const parseSamples: ({ iterator, maxBytes, options, signal, }: {
+export declare const parseSamples: ({ iterator, maxBytes, options, signal, logLevel, }: {
     iterator: BufferIterator;
     maxBytes: number;
     options: ParserContext;
     signal: AbortSignal | null;
+    logLevel: LogLevel;
 }) => Promise<Sample[]>;
 export {};

package/dist/boxes/iso-base-media/stsd/samples.js

@@ -61,7 +61,7 @@ const audioTags = [
     'mp4a',
     'ac-3',
 ];
-const processSample = async ({ iterator, options, signal, }) => {
+const processSample = async ({ iterator, options, signal, logLevel, }) => {
     const fileOffset = iterator.counter.getOffset();
     const bytesRemaining = iterator.bytesRemaining();
     const boxSize = iterator.getUint32();
@@ -105,8 +105,8 @@ const processSample = async ({ iterator, options, signal, }) => {
                 initialBoxes: [],
                 options,
                 continueMdat: false,
-                littleEndian: false,
                 signal,
+                logLevel,
             });
             if (children.status === 'incomplete') {
                 throw new Error('Incomplete boxes are not allowed');
@@ -152,8 +152,8 @@ const processSample = async ({ iterator, options, signal, }) => {
                 initialBoxes: [],
                 options,
                 continueMdat: false,
-                littleEndian: false,
                 signal,
+                logLevel,
             });
             if (children.status === 'incomplete') {
                 throw new Error('Incomplete boxes are not allowed');
@@ -203,8 +203,8 @@ const processSample = async ({ iterator, options, signal, }) => {
                 initialBoxes: [],
                 options,
                 continueMdat: false,
-                littleEndian: false,
                 signal,
+                logLevel,
             });
             if (children.status === 'incomplete') {
                 throw new Error('Incomplete boxes are not allowed');
@@ -258,8 +258,8 @@ const processSample = async ({ iterator, options, signal, }) => {
                 initialBoxes: [],
                 options,
                 continueMdat: false,
-                littleEndian: false,
                 signal,
+                logLevel,
             })
             : (iterator.discard(bytesRemainingInBox),
                 { status: 'done', segments: [] });
@@ -294,7 +294,7 @@ const processSample = async ({ iterator, options, signal, }) => {
     throw new Error(`Unknown sample format ${boxFormat}`);
 };
 exports.processSample = processSample;
-const parseSamples = async ({ iterator, maxBytes, options, signal, }) => {
+const parseSamples = async ({ iterator, maxBytes, options, signal, logLevel, }) => {
     const samples = [];
     const initialOffset = iterator.counter.getOffset();
     while (iterator.bytesRemaining() > 0 &&
@@ -303,6 +303,7 @@ const parseSamples = async ({ iterator, maxBytes, options, signal, }) => {
             iterator,
             options,
             signal,
+            logLevel,
         });
         if (sample) {
             samples.push(sample);

package/dist/boxes/iso-base-media/stsd/stsd.js

@@ -16,6 +16,7 @@ const parseStsd = async ({ iterator, offset, size, options, signal, }) => {
         maxBytes: bytesRemainingInBox,
         options,
         signal,
+        logLevel: 'info',
     });
     if (boxes.length !== numberOfEntries) {
         throw new Error(`Expected ${numberOfEntries} sample descriptions, got ${boxes.length}`);

package/dist/boxes/iso-base-media/to-date.d.ts

@@ -1 +1,2 @@
 export declare const toUnixTimestamp: (value: number) => number | null;
+export declare const fromUnixTimestamp: (value: number | null) => number;

package/dist/boxes/iso-base-media/to-date.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toUnixTimestamp = void 0;
+exports.fromUnixTimestamp = exports.toUnixTimestamp = void 0;
 const toUnixTimestamp = (value) => {
     if (value === 0) {
         return null;
@@ -9,3 +9,11 @@ const toUnixTimestamp = (value) => {
     return Math.floor(value + baseDate.getTime() / 1000) * 1000;
 };
 exports.toUnixTimestamp = toUnixTimestamp;
+const fromUnixTimestamp = (value) => {
+    if (value === null) {
+        return 0;
+    }
+    const baseDate = new Date('1904-01-01T00:00:00Z');
+    return Math.floor(value / 1000 - baseDate.getTime() / 1000);
+};
+exports.fromUnixTimestamp = fromUnixTimestamp;

package/dist/boxes/iso-base-media/trak/trak.d.ts

@@ -1,4 +1,5 @@
 import type { BufferIterator } from '../../../buffer-iterator';
+import type { LogLevel } from '../../../log';
 import type { AnySegment } from '../../../parse-result';
 import type { ParserContext } from '../../../parser-context';
 import type { BaseBox } from '../base-type';
@@ -6,10 +7,11 @@ export interface TrakBox extends BaseBox {
     type: 'trak-box';
     children: AnySegment[];
 }
-export declare const parseTrak: ({ data, size, offsetAtStart, options, signal, }: {
+export declare const parseTrak: ({ data, size, offsetAtStart, options, signal, logLevel, }: {
     data: BufferIterator;
     size: number;
     offsetAtStart: number;
     options: ParserContext;
     signal: AbortSignal | null;
+    logLevel: LogLevel;
 }) => Promise<TrakBox>;

package/dist/boxes/iso-base-media/trak/trak.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTrak = void 0;
 const process_box_1 = require("../process-box");
-const parseTrak = async ({ data, size, offsetAtStart, options, signal, }) => {
+const parseTrak = async ({ data, size, offsetAtStart, options, signal, logLevel, }) => {
     const children = await (0, process_box_1.parseBoxes)({
         iterator: data,
         maxBytes: size - (data.counter.getOffset() - offsetAtStart),
@@ -10,8 +10,8 @@ const parseTrak = async ({ data, size, offsetAtStart, options, signal, }) => {
         initialBoxes: [],
         options,
         continueMdat: false,
-        littleEndian: false,
         signal,
+        logLevel,
     });
     if (children.status === 'incomplete') {
         throw new Error('Incomplete boxes are not allowed');

package/dist/boxes/webm/av1-codec-private.js

@@ -61,7 +61,7 @@ const parseAv1PrivateData = (data, colrAtom) => {
                 : '0'
             : '0';
     str += '.';
-    if (colrAtom) {
+    if (colrAtom && colrAtom.colorType === 'transfer-characteristics') {
         str += colrAtom.primaries.toString().padStart(2, '0');
         str += '.';
         str += colrAtom.transfer.toString().padStart(2, '0');

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

@@ -1,2 +1,2 @@
-export declare const measureEBMLVarInt: (value: number) => 1 | 4 | 2 | 3 | 5 | 6;
+export declare const measureEBMLVarInt: (value: number) => 1 | 2 | 3 | 4 | 5 | 6;
 export declare const getVariableInt: (value: number, minWidth: number | null) => Uint8Array;

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

@@ -1,15 +1,15 @@
 import type { ParserContext } from '../../parser-context';
-import type { AudioSample, VideoSample } from '../../webcodec-sample-types';
+import type { AudioOrVideoSample } from '../../webcodec-sample-types';
 import type { BlockSegment, SimpleBlockSegment } from './segments/all-segments';
 type SampleResult = {
     type: 'video-sample';
-    videoSample: VideoSample;
+    videoSample: AudioOrVideoSample;
 } | {
     type: 'audio-sample';
-    audioSample: AudioSample;
+    audioSample: AudioOrVideoSample;
 } | {
     type: 'partial-video-sample';
-    partialVideoSample: Omit<VideoSample, 'type'>;
+    partialVideoSample: Omit<AudioOrVideoSample, 'type'>;
 } | {
     type: 'no-sample';
 };

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

@@ -34,8 +34,8 @@ const getSampleFromBlock = (ebml, parserContext, offset) => {
     if (codec.startsWith('V_')) {
         const partialVideoSample = {
             data: iterator.getSlice(remainingNow),
-            cts: null,
-            dts: null,
+            cts: timecodeInMicroseconds,
+            dts: timecodeInMicroseconds,
             duration: undefined,
             trackId: trackNumber,
             timestamp: timecodeInMicroseconds,
@@ -64,6 +64,8 @@ const getSampleFromBlock = (ebml, parserContext, offset) => {
             timestamp: timecodeInMicroseconds,
             type: 'key',
             duration: undefined,
+            cts: timecodeInMicroseconds,
+            dts: timecodeInMicroseconds,
         };
         iterator.destroy();
         return {

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

@@ -231,6 +231,7 @@ const getTrack = ({ timescale, track, }) => {
             codecWithoutConfig: getMatroskaVideoCodecWithoutConfigString({
                 codecSegment: codec,
             }),
+            fps: null,
         };
     }
     if ((0, track_entry_1.trackTypeToString)(trackType.value.value) === 'audio') {

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

@@ -2,14 +2,33 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseWebm = void 0;
 const parse_children_1 = require("./segments/parse-children");
+const continueAfterMatroskaResult = (result, children) => {
+    if (result.status === 'done') {
+        return {
+            status: 'done',
+            segments: children,
+        };
+    }
+    return {
+        status: 'incomplete',
+        segments: children,
+        continueParsing: async () => {
+            const newResult = await result.continueParsing();
+            return continueAfterMatroskaResult(newResult, children);
+        },
+        skipTo: null,
+    };
+};
 // Parsing according to https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/
-const parseWebm = (counter, parserContext) => {
-    return (0, parse_children_1.expectChildren)({
+const parseWebm = async (counter, parserContext) => {
+    const children = [];
+    const results = await (0, parse_children_1.expectChildren)({
         iterator: counter,
         length: Infinity,
-        initialChildren: [],
-        wrap: null,
+        children,
         parserContext,
+        startOffset: counter.counter.getOffset(),
     });
+    return continueAfterMatroskaResult(results, children);
 };
 exports.parseWebm = parseWebm;

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

@@ -1,13 +1,18 @@
 import type { BufferIterator } from '../../../buffer-iterator';
-import type { ParseResult } from '../../../parse-result';
+import type { ExpectSegmentParseResult, MatroskaParseResult } from '../../../parse-result';
 import type { ParserContext } from '../../../parser-context';
 import type { MatroskaSegment } from '../segments';
-type WrapChildren = (segments: MatroskaSegment[]) => MatroskaSegment;
-export declare const expectChildren: ({ iterator, length, initialChildren, wrap, parserContext, }: {
+import type { PossibleEbml } from './all-segments';
+export declare const expectAndProcessSegment: ({ iterator, parserContext, offset, children, }: {
+    iterator: BufferIterator;
+    parserContext: ParserContext;
+    offset: number;
+    children: PossibleEbml[];
+}) => Promise<ExpectSegmentParseResult>;
+export declare const expectChildren: ({ iterator, length, children, parserContext, startOffset, }: {
     iterator: BufferIterator;
     length: number;
-    initialChildren: MatroskaSegment[];
-    wrap: WrapChildren | null;
+    children: MatroskaSegment[];
     parserContext: ParserContext;
-}) => Promise<ParseResult>;
-export {};
+    startOffset: number;
+}) => Promise<MatroskaParseResult>;

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

@@ -1,100 +1,110 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.expectChildren = void 0;
+exports.expectChildren = exports.expectAndProcessSegment = void 0;
 const segments_1 = require("../segments");
-const processParseResult = ({ parseResult, children, wrap, }) => {
+const processParseResult = ({ parseResult, children, }) => {
+    if (parseResult.segment && !children.includes(parseResult.segment)) {
+        children.push(parseResult.segment);
+    }
     if (parseResult.status === 'incomplete') {
         // No need to decrement because expectSegment already does it
         return {
             status: 'incomplete',
-            segments: [],
+            segment: parseResult.segment,
             continueParsing: async () => {
                 const newParseResult = await parseResult.continueParsing();
                 return processParseResult({
                     children,
                     parseResult: newParseResult,
-                    wrap,
                 });
             },
-            skipTo: null,
         };
     }
-    for (const segment of parseResult.segments) {
-        children.push(segment);
-    }
     return {
         status: 'done',
-        segments: wrap ? [wrap(children)] : children,
+        segment: parseResult.segment,
     };
 };
-const continueParsingfunction = ({ result, iterator, children, wrap, parserContext, length, }) => async () => {
-    if (result.status !== 'incomplete') {
-        throw new Error('expected incomplete');
+const expectAndProcessSegment = async ({ iterator, parserContext, offset, children, }) => {
+    const segment = await (0, segments_1.expectSegment)({
+        iterator,
+        parserContext,
+        offset,
+        children,
+    });
+    return processParseResult({
+        children,
+        parseResult: segment,
+    });
+};
+exports.expectAndProcessSegment = expectAndProcessSegment;
+const continueAfterSegmentResult = async ({ result, length, children, parserContext, iterator, startOffset, }) => {
+    if (result.status === 'done') {
+        throw new Error('Should not continue after done');
     }
-    const offset = iterator.counter.getOffset();
-    const continued = await result.continueParsing();
-    if (continued.status === 'incomplete') {
-        if (!parserContext.supportsContentRange) {
-            throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
-        }
+    const segmentResult = await result.continueParsing();
+    if (segmentResult.status === 'done') {
         return {
             status: 'incomplete',
-            continueParsing: continueParsingfunction({
-                result: continued,
-                iterator,
-                children,
-                wrap,
-                parserContext,
-                length: length - (iterator.counter.getOffset() - offset),
-            }),
-            skipTo: continued.skipTo,
-            segments: wrap ? [wrap(children)] : children,
+            continueParsing: () => {
+                // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                return (0, exports.expectChildren)({
+                    children,
+                    iterator,
+                    length,
+                    parserContext,
+                    startOffset,
+                });
+            },
+            skipTo: null,
         };
     }
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    return (0, exports.expectChildren)({
-        iterator,
-        length: length - (iterator.counter.getOffset() - offset),
-        initialChildren: children,
-        wrap,
-        parserContext,
-    });
+    return {
+        status: 'incomplete',
+        continueParsing: () => {
+            return continueAfterSegmentResult({
+                result: segmentResult,
+                children,
+                iterator,
+                length,
+                parserContext,
+                startOffset,
+            });
+        },
+        skipTo: null,
+    };
 };
-const expectChildren = async ({ iterator, length, initialChildren, wrap, parserContext, }) => {
-    const children = [...initialChildren];
-    const startOffset = iterator.counter.getOffset();
+const expectChildren = async ({ iterator, length, children, parserContext, startOffset, }) => {
     while (iterator.counter.getOffset() < startOffset + length) {
         if (iterator.bytesRemaining() === 0) {
             break;
         }
-        const parseResult = await (0, segments_1.expectSegment)(iterator, parserContext);
-        const child = processParseResult({
+        const currentOffset = iterator.counter.getOffset();
+        const child = await (0, exports.expectAndProcessSegment)({
+            iterator,
+            parserContext,
+            offset: currentOffset,
             children,
-            parseResult,
-            wrap,
         });
         if (child.status === 'incomplete') {
-            if (!parserContext.supportsContentRange) {
-                throw new Error('Content-Range header is not supported by the reader, but was asked to seek');
-            }
             return {
                 status: 'incomplete',
-                continueParsing: continueParsingfunction({
-                    result: child,
-                    iterator,
-                    children,
-                    wrap,
-                    parserContext,
-                    length: length - (iterator.counter.getOffset() - startOffset),
-                }),
-                skipTo: child.skipTo,
-                segments: wrap ? [wrap(children)] : children,
+                continueParsing: () => {
+                    return continueAfterSegmentResult({
+                        result: child,
+                        children,
+                        iterator,
+                        length: length - (currentOffset - startOffset),
+                        parserContext,
+                        startOffset: currentOffset,
+                    });
+                },
+                skipTo: null,
             };
         }
     }
     return {
         status: 'done',
-        segments: wrap ? [wrap(children)] : children,
     };
 };
 exports.expectChildren = expectChildren;

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

@@ -1,7 +1,12 @@
 import type { BufferIterator } from '../../buffer-iterator';
-import type { ParseResult } from '../../parse-result';
+import type { ExpectSegmentParseResult } from '../../parse-result';
 import type { ParserContext } from '../../parser-context';
-import type { PossibleEbml, TrackEntry } from './segments/all-segments';
+import { type PossibleEbml, type TrackEntry } from './segments/all-segments';
 export type MatroskaSegment = PossibleEbml;
 export type OnTrackEntrySegment = (trackEntry: TrackEntry) => void;
-export declare const expectSegment: (iterator: BufferIterator, parserContext: ParserContext) => Promise<ParseResult>;
+export declare const expectSegment: ({ iterator, parserContext, offset, children, }: {
+    iterator: BufferIterator;
+    parserContext: ParserContext;
+    offset: number;
+    children: PossibleEbml[];
+}) => Promise<ExpectSegmentParseResult>;