@remotion/media-parser 4.0.201 → 4.0.204

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

@@ -6,12 +6,13 @@ const make_hvc1_codec_strings_1 = require("../../make-hvc1-codec-strings");
 const traversal_1 = require("../../traversal");
 const av1_codec_private_1 = require("./av1-codec-private");
 const description_1 = require("./description");
+const track_entry_1 = require("./segments/track-entry");
 const getDescription = (track) => {
     const codec = (0, traversal_1.getCodecSegment)(track);
     if (!codec) {
         return undefined;
     }
-    if (codec.codec === 'V_MPEG4/ISO/AVC' || codec.codec === 'V_MPEGH/ISO/HEVC') {
+    if (codec.value === 'V_MPEG4/ISO/AVC' || codec.value === 'V_MPEGH/ISO/HEVC') {
         const priv = (0, traversal_1.getPrivateData)(track);
         if (priv) {
             return priv;
@@ -20,49 +21,49 @@ const getDescription = (track) => {
     return undefined;
 };
 const getMatroskaVideoCodecString = ({ track, codecSegment: codec, }) => {
-    if (codec.codec === 'V_VP8') {
+    if (codec.value === 'V_VP8') {
         return 'vp8';
     }
-    if (codec.codec === 'V_VP9') {
+    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?');
         }
         return 'vp09.00.10.08';
     }
-    if (codec.codec === 'V_MPEG4/ISO/AVC') {
+    if (codec.value === 'V_MPEG4/ISO/AVC') {
         const priv = (0, traversal_1.getPrivateData)(track);
         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');
     }
-    if (codec.codec === 'V_AV1') {
+    if (codec.value === 'V_AV1') {
         const priv = (0, traversal_1.getPrivateData)(track);
         if (!priv) {
             throw new Error('Expected private data in AV1 track');
         }
         return (0, av1_codec_private_1.parseAv1PrivateData)(priv, null);
     }
-    if (codec.codec === 'V_MPEGH/ISO/HEVC') {
+    if (codec.value === 'V_MPEGH/ISO/HEVC') {
         const priv = (0, traversal_1.getPrivateData)(track);
-        const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(priv);
+        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.codec}`);
+    throw new Error(`Unknown codec: ${codec.value}`);
 };
 const getMatroskaAudioCodecString = (track) => {
     const codec = (0, traversal_1.getCodecSegment)(track);
     if (!codec) {
         throw new Error('Expected codec segment');
     }
-    if (codec.codec === 'A_OPUS') {
+    if (codec.value === 'A_OPUS') {
         return 'opus';
     }
-    if (codec.codec === 'A_VORBIS') {
+    if (codec.value === 'A_VORBIS') {
         return 'vorbis';
     }
-    if (codec.codec === 'A_PCM/INT/LIT') {
+    if (codec.value === 'A_PCM/INT/LIT') {
         // https://github.com/ietf-wg-cellar/matroska-specification/issues/142#issuecomment-330004950
         // Audio samples MUST be considered as signed values, except if the audio bit depth is 8 which MUST be interpreted as unsigned values.
         const bitDepth = (0, traversal_1.getBitDepth)(track);
@@ -74,9 +75,9 @@ const getMatroskaAudioCodecString = (track) => {
         }
         return 'pcm-s' + bitDepth;
     }
-    if (codec.codec === 'A_AAC') {
+    if (codec.value === 'A_AAC') {
         const priv = (0, traversal_1.getPrivateData)(track);
-        const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(priv);
+        const iterator = (0, buffer_iterator_1.getArrayBufferIterator)(priv, priv.length);
         iterator.startReadingBits();
         /**
          * ChatGPT
@@ -104,10 +105,10 @@ const getMatroskaAudioCodecString = (track) => {
         iterator.destroy();
         return `mp4a.40.${profile.toString().padStart(2, '0')}`;
     }
-    if (codec.codec === 'A_MPEG/L3') {
+    if (codec.value === 'A_MPEG/L3') {
         return 'mp3';
     }
-    throw new Error(`Unknown codec: ${codec.codec}`);
+    throw new Error(`Unknown codec: ${codec.value}`);
 };
 const getTrack = ({ timescale, track, }) => {
     const trackType = (0, traversal_1.getTrackTypeSegment)(track);
@@ -115,7 +116,7 @@ const getTrack = ({ timescale, track, }) => {
         throw new Error('Expected track type segment');
     }
     const trackId = (0, traversal_1.getTrackId)(track);
-    if (trackType.trackType === 'video') {
+    if ((0, track_entry_1.trackTypeToString)(trackType.value.value) === 'video') {
         const width = (0, traversal_1.getWidthSegment)(track);
         if (width === null) {
             throw new Error('Expected width segment');
@@ -142,26 +143,26 @@ const getTrack = ({ timescale, track, }) => {
             trackId,
             codec: codecString,
             description: getDescription(track),
-            height: displayHeight ? displayHeight.displayHeight : height.height,
-            width: displayWidth ? displayWidth.displayWidth : width.width,
+            height: displayHeight ? displayHeight.value.value : height.value.value,
+            width: displayWidth ? displayWidth.value.value : width.value.value,
             sampleAspectRatio: {
                 numerator: 1,
                 denominator: 1,
             },
             timescale,
             samplePositions: [],
-            codedHeight: height.height,
-            codedWidth: width.width,
+            codedHeight: height.value.value,
+            codedWidth: width.value.value,
             displayAspectHeight: displayHeight
-                ? displayHeight.displayHeight
-                : height.height,
+                ? displayHeight.value.value
+                : height.value.value,
             displayAspectWidth: displayWidth
-                ? displayWidth.displayWidth
-                : width.width,
+                ? displayWidth.value.value
+                : width.value.value,
             rotation: 0,
         };
     }
-    if (trackType.trackType === 'audio') {
+    if ((0, track_entry_1.trackTypeToString)(trackType.value.value) === 'audio') {
         const sampleRate = (0, traversal_1.getSampleRate)(track);
         const numberOfChannels = (0, traversal_1.getNumberOfChannels)(track);
         if (sampleRate === null) {

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

@@ -1,9 +1,4 @@
-import type { Ebml, EbmlWithChildren, EbmlWithHexString, EbmlWithString, EbmlWithUint8, EmblTypes, HeaderStructure } from './segments/all-segments';
+import type { PossibleEbmlOrUint8Array } from './segments/all-segments';
 export declare const webmPattern: Uint8Array;
-type Numbers = '0' | '1' | '2' | '3' | '4' | '5' | '6';
-type ChildFields<Struct extends HeaderStructure> = {
-    [key in keyof Struct & Numbers as Struct[key]['name']]: EmblTypes[Struct[key]['type']];
-};
-type SerializeValue<Struct extends Ebml> = Struct extends EbmlWithChildren ? ChildFields<Struct['children']> : Struct extends EbmlWithString ? string : Struct extends EbmlWithUint8 ? number : Struct extends EbmlWithHexString ? string : undefined;
-export declare const makeMatroskaHeader: <Struct extends Ebml>(struct: Struct, fields: SerializeValue<Struct>) => Uint8Array;
-export {};
+export declare const makeMatroskaBytes: (fields: PossibleEbmlOrUint8Array) => Uint8Array;
+export declare const combineUint8Arrays: (arrays: Uint8Array[]) => Uint8Array;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeMatroskaHeader = exports.webmPattern = void 0;
+exports.combineUint8Arrays = exports.makeMatroskaBytes = exports.webmPattern = void 0;
 const ebml_1 = require("./ebml");
 const all_segments_1 = require("./segments/all-segments");
 exports.webmPattern = new Uint8Array([0x1a, 0x45, 0xdf, 0xa3]);
@@ -12,12 +12,12 @@ const matroskaToHex = (matrId) => {
     }
     return numbers;
 };
-function putUintDynamic(number) {
+function putUintDynamic(number, minimumLength) {
     if (number < 0) {
         throw new Error('This function is designed for non-negative integers only.');
     }
     // Calculate the minimum number of bytes needed to store the integer
-    const length = Math.ceil(Math.log2(number + 1) / 8);
+    const length = Math.max(minimumLength !== null && minimumLength !== void 0 ? minimumLength : 0, Math.ceil(Math.log2(number + 1) / 8));
     const bytes = new Uint8Array(length);
     for (let i = 0; i < length; i++) {
         // Extract each byte from the number
@@ -25,24 +25,29 @@ function putUintDynamic(number) {
     }
     return bytes;
 }
-const makeFromHeaderStructure = (struct, fields) => {
+const makeFromHeaderStructure = (fields) => {
+    if (fields instanceof Uint8Array) {
+        return fields;
+    }
     const arrays = [];
+    const struct = all_segments_1.ebmlMap[(0, all_segments_1.getIdForName)(fields.type)];
+    if (struct.type === 'uint8array') {
+        return fields.value;
+    }
     if (struct.type === 'children') {
-        for (const item of struct.children) {
-            arrays.push((0, exports.makeMatroskaHeader)(item, 
-            // @ts-expect-error
-            fields[item.name]));
+        for (const item of fields.value) {
+            arrays.push((0, exports.makeMatroskaBytes)(item));
         }
-        return combineUint8Arrays(arrays);
+        return (0, exports.combineUint8Arrays)(arrays);
     }
     if (struct.type === 'string') {
-        return new TextEncoder().encode(fields);
+        return new TextEncoder().encode(fields.value);
     }
     if (struct.type === 'uint') {
-        return putUintDynamic(fields);
+        return putUintDynamic(fields.value.value, fields.value.byteLength);
     }
     if (struct.type === 'hex-string') {
-        const hex = fields.substring(2);
+        const hex = fields.value.substring(2);
         const arr = new Uint8Array(hex.length / 2);
         for (let i = 0; i < hex.length; i += 2) {
             const byte = parseInt(hex.substring(i, i + 2), 16);
@@ -50,21 +55,38 @@ const makeFromHeaderStructure = (struct, fields) => {
         }
         return arr;
     }
-    if (struct.type === 'void') {
-        throw new Error('Serializing Void is not implemented');
+    if (struct.type === 'float') {
+        const value = fields.value;
+        if (value.size === '32') {
+            const dataView = new DataView(new ArrayBuffer(4));
+            dataView.setFloat32(0, value.value);
+            return new Uint8Array(dataView.buffer);
+        }
+        const dataView2 = new DataView(new ArrayBuffer(8));
+        dataView2.setFloat64(0, value.value);
+        return new Uint8Array(dataView2.buffer);
     }
     throw new Error('Unexpected type');
 };
-const makeMatroskaHeader = (struct, fields) => {
-    const value = makeFromHeaderStructure(struct, fields);
-    return combineUint8Arrays([
-        matroskaToHex((0, all_segments_1.getIdForName)(struct.name)),
-        (0, ebml_1.getVariableInt)(value.length),
+const makeMatroskaBytes = (fields) => {
+    if (fields instanceof Uint8Array) {
+        return fields;
+    }
+    const value = makeFromHeaderStructure(fields);
+    return (0, exports.combineUint8Arrays)([
+        matroskaToHex((0, all_segments_1.getIdForName)(fields.type)),
+        (0, ebml_1.getVariableInt)(value.length, fields.minVintWidth),
         value,
     ]);
 };
-exports.makeMatroskaHeader = makeMatroskaHeader;
+exports.makeMatroskaBytes = makeMatroskaBytes;
 const combineUint8Arrays = (arrays) => {
+    if (arrays.length === 0) {
+        return new Uint8Array([]);
+    }
+    if (arrays.length === 1) {
+        return arrays[0];
+    }
     let totalLength = 0;
     for (const array of arrays) {
         totalLength += array.length;
@@ -77,3 +99,4 @@ const combineUint8Arrays = (arrays) => {
     }
     return result;
 };
+exports.combineUint8Arrays = combineUint8Arrays;

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

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

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

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseEbml = void 0;
+exports.postprocessEbml = exports.parseEbml = void 0;
+const add_new_matroska_tracks_1 = require("../../add-new-matroska-tracks");
+const get_sample_from_block_1 = require("./get-sample-from-block");
+const get_track_1 = require("./get-track");
 const all_segments_1 = require("./segments/all-segments");
-const parseEbml = (iterator) => {
+const parseEbml = async (iterator, parserContext) => {
     const hex = iterator.getMatroskaSegmentId();
     if (hex === null) {
         throw new Error('Not enough bytes left to parse EBML - this should not happen');
@@ -11,36 +14,58 @@ const parseEbml = (iterator) => {
     if (!hasInMap) {
         throw new Error(`Don't know how to parse EBML hex ID ${JSON.stringify(hex)}`);
     }
+    const off = iterator.counter.getOffset();
     const size = iterator.getVint();
+    const minVintWidth = iterator.counter.getOffset() - off;
     if (size === null) {
         throw new Error('Not enough bytes left to parse EBML - this should not happen');
     }
     if (hasInMap.type === 'uint') {
+        const beforeUintOffset = iterator.counter.getOffset();
         const value = iterator.getUint(size);
-        return { type: hasInMap.name, value, hex };
+        return {
+            type: hasInMap.name,
+            value: {
+                value,
+                byteLength: iterator.counter.getOffset() - beforeUintOffset,
+            },
+            minVintWidth,
+        };
     }
     if (hasInMap.type === 'string') {
         const value = iterator.getByteString(size);
         return {
             type: hasInMap.name,
             value,
-            hex,
+            minVintWidth,
         };
     }
     if (hasInMap.type === 'float') {
         const value = size === 4 ? iterator.getFloat32() : iterator.getFloat64();
         return {
             type: hasInMap.name,
-            value,
-            hex,
+            value: {
+                value,
+                size: size === 4 ? '32' : '64',
+            },
+            minVintWidth,
         };
     }
-    if (hasInMap.type === 'void') {
-        iterator.discard(size);
+    if (hasInMap.type === 'hex-string') {
         return {
             type: hasInMap.name,
-            value: undefined,
-            hex,
+            value: '0x' +
+                [...iterator.getSlice(size)]
+                    .map((b) => b.toString(16).padStart(2, '0'))
+                    .join(''),
+            minVintWidth,
+        };
+    }
+    if (hasInMap.type === 'uint8array') {
+        return {
+            type: hasInMap.name,
+            value: iterator.getSlice(size),
+            minVintWidth,
         };
     }
     if (hasInMap.type === 'children') {
@@ -48,8 +73,14 @@ const parseEbml = (iterator) => {
         const startOffset = iterator.counter.getOffset();
         // eslint-disable-next-line no-constant-condition
         while (true) {
-            const value = (0, exports.parseEbml)(iterator);
-            children.push(value);
+            const offset = iterator.counter.getOffset();
+            const value = await (0, exports.parseEbml)(iterator, parserContext);
+            const remapped = await (0, exports.postprocessEbml)({
+                offset,
+                ebml: value,
+                parserContext,
+            });
+            children.push(remapped);
             const offsetNow = iterator.counter.getOffset();
             if (offsetNow - startOffset > size) {
                 throw new Error(`Offset ${offsetNow - startOffset} is larger than the length of the hex ${size}`);
@@ -58,9 +89,87 @@ const parseEbml = (iterator) => {
                 break;
             }
         }
-        return { type: hasInMap.name, value: children, hex };
+        return { type: hasInMap.name, value: children, minVintWidth };
     }
     // @ts-expect-error
     throw new Error(`Unknown segment type ${hasInMap.type}`);
 };
 exports.parseEbml = parseEbml;
+const postprocessEbml = async ({ offset, ebml, parserContext, }) => {
+    if (ebml.type === 'TimestampScale') {
+        parserContext.parserState.setTimescale(ebml.value.value);
+    }
+    if (ebml.type === 'TrackEntry') {
+        parserContext.parserState.onTrackEntrySegment(ebml);
+        const track = (0, get_track_1.getTrack)({
+            track: ebml,
+            timescale: parserContext.parserState.getTimescale(),
+        });
+        if (track) {
+            await (0, add_new_matroska_tracks_1.registerTrack)({
+                state: parserContext.parserState,
+                options: parserContext,
+                track,
+            });
+        }
+    }
+    if (ebml.type === 'Timestamp') {
+        parserContext.parserState.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);
+            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);
+            return {
+                type: 'Block',
+                value: new Uint8Array([]),
+                minVintWidth: ebml.minVintWidth,
+            };
+        }
+        if (sample.type === 'no-sample' && parserContext.nullifySamples) {
+            return {
+                type: 'Block',
+                value: new Uint8Array([]),
+                minVintWidth: ebml.minVintWidth,
+            };
+        }
+    }
+    if (ebml.type === 'BlockGroup') {
+        // Blocks don't have information about keyframes.
+        // https://ffmpeg.org/pipermail/ffmpeg-devel/2015-June/173825.html
+        // "For Blocks, keyframes is
+        // inferred by the absence of ReferenceBlock element (as done by matroskadec).""
+        const block = ebml.value.find((c) => c.type === 'SimpleBlock' || c.type === 'Block');
+        if (!block || (block.type !== 'SimpleBlock' && block.type !== 'Block')) {
+            throw new Error('Expected block segment');
+        }
+        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);
+        if (sample && sample.type === 'partial-video-sample') {
+            const completeFrame = {
+                ...sample.partialVideoSample,
+                type: hasReferenceBlock ? 'delta' : 'key',
+            };
+            await parserContext.parserState.onVideoSample(sample.partialVideoSample.trackId, completeFrame);
+        }
+        if (parserContext.nullifySamples) {
+            return {
+                type: 'BlockGroup',
+                value: [],
+                minVintWidth: ebml.minVintWidth,
+            };
+        }
+    }
+    return ebml;
+};
+exports.postprocessEbml = postprocessEbml;