@remotion/media-parser 4.0.201 → 4.0.202

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;