@remotion/media-parser 4.0.200 → 4.0.202

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

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = async (iterator, parserContext) => {
+    const hex = iterator.getMatroskaSegmentId();
+    if (hex === null) {
+        throw new Error('Not enough bytes left to parse EBML - this should not happen');
+    }
+    const hasInMap = all_segments_1.ebmlMap[hex];
+    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: {
+                value,
+                byteLength: iterator.counter.getOffset() - beforeUintOffset,
+            },
+            minVintWidth,
+        };
+    }
+    if (hasInMap.type === 'string') {
+        const value = iterator.getByteString(size);
+        return {
+            type: hasInMap.name,
+            value,
+            minVintWidth,
+        };
+    }
+    if (hasInMap.type === 'float') {
+        const value = size === 4 ? iterator.getFloat32() : iterator.getFloat64();
+        return {
+            type: hasInMap.name,
+            value: {
+                value,
+                size: size === 4 ? '32' : '64',
+            },
+            minVintWidth,
+        };
+    }
+    if (hasInMap.type === 'hex-string') {
+        return {
+            type: hasInMap.name,
+            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') {
+        const children = [];
+        const startOffset = iterator.counter.getOffset();
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            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}`);
+            }
+            if (offsetNow - startOffset === size) {
+                break;
+            }
+        }
+        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;

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

@@ -1,16 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseWebm = void 0;
-const segments_1 = require("./segments");
+const parse_children_1 = require("./segments/parse-children");
 // Parsing according to https://darkcoding.net/software/reading-mediarecorders-webm-opus-output/
 const parseWebm = (counter, parserContext) => {
-    counter.discard(4);
-    const length = counter.getVint();
-    if (length !== 31 && length !== 35) {
-        throw new Error(`Expected header length 31 or 25, got ${length}`);
-    }
-    // Discard header for now
-    counter.discard(length);
-    return (0, segments_1.expectSegment)(counter, parserContext);
+    return (0, parse_children_1.expectChildren)({
+        iterator: counter,
+        length: Infinity,
+        initialChildren: [],
+        wrap: null,
+        parserContext,
+    });
 };
 exports.parseWebm = parseWebm;