@remotion/media-parser 4.0.249 → 4.0.250

package/dist/boxes/webm/segments.js

@@ -1,152 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.expectSegment = void 0;
+const log_1 = require("../../log");
 const parse_ebml_1 = require("./parse-ebml");
-const parse_children_1 = require("./segments/parse-children");
-const continueAfterMatroskaParseResult = async ({ result, iterator, state, segment, }) => {
-    if (result.status === 'done') {
-        throw new Error('Should not continue after done');
-    }
-    const proceeded = await result.continueParsing();
-    if (proceeded.status === 'done') {
-        return {
-            status: 'done',
-            segment,
-        };
-    }
-    return {
-        continueParsing() {
-            return continueAfterMatroskaParseResult({
-                result: proceeded,
-                iterator,
-                state,
-                segment,
-            });
-        },
-        segment: null,
-        status: 'incomplete',
-    };
-};
-const expectSegment = async ({ iterator, state, offset, children, fields, topLevelStructure, }) => {
-    iterator.counter.decrement(iterator.counter.getOffset() - offset);
+const all_segments_1 = require("./segments/all-segments");
+const expectSegment = async ({ iterator, state, isInsideSegment, }) => {
+    var _a;
     if (iterator.bytesRemaining() === 0) {
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                return (0, parse_children_1.expectAndProcessSegment)({
-                    iterator,
-                    state,
-                    offset,
-                    children,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-            segment: null,
-        };
+        throw new Error('has no bytes');
     }
+    const offset = iterator.counter.getOffset();
+    const { returnToCheckpoint } = iterator.startCheckpoint();
     const segmentId = iterator.getMatroskaSegmentId();
     if (segmentId === null) {
-        iterator.counter.decrement(iterator.counter.getOffset() - offset);
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                return (0, parse_children_1.expectAndProcessSegment)({
-                    iterator,
-                    state,
-                    offset,
-                    children,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-            segment: null,
-        };
+        returnToCheckpoint();
+        return null;
     }
     const offsetBeforeVInt = iterator.counter.getOffset();
-    const length = iterator.getVint();
+    const size = iterator.getVint();
     const offsetAfterVInt = iterator.counter.getOffset();
-    if (length === null) {
-        iterator.counter.decrement(iterator.counter.getOffset() - offset);
-        return {
-            status: 'incomplete',
-            continueParsing: () => {
-                return (0, exports.expectSegment)({
-                    iterator,
-                    state,
-                    offset,
-                    children,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-            segment: null,
-        };
+    if (size === null) {
+        returnToCheckpoint();
+        return null;
     }
-    const bytesRemainingNow = iterator.byteLength() - iterator.counter.getOffset();
-    if (segmentId === '0x18538067' || segmentId === '0x1f43b675') {
+    const bytesRemainingNow = iterator.bytesRemaining();
+    log_1.Log.trace(state.logLevel, 'Segment ID:', (_a = all_segments_1.ebmlMap[segmentId]) === null || _a === void 0 ? void 0 : _a.name, 'Size:' + size, bytesRemainingNow);
+    if (segmentId === all_segments_1.matroskaElements.Segment) {
+        state.webm.addSegment({
+            start: offset,
+            size,
+        });
         const newSegment = {
-            type: segmentId === '0x18538067' ? 'Segment' : 'Cluster',
+            type: 'Segment',
             minVintWidth: offsetAfterVInt - offsetBeforeVInt,
             value: [],
         };
-        const main = await (0, parse_children_1.expectChildren)({
-            iterator,
-            length,
-            children: newSegment.value,
-            state,
-            startOffset: iterator.counter.getOffset(),
-            fields,
-            topLevelStructure,
-        });
-        if (main.status === 'incomplete') {
-            return {
-                status: 'incomplete',
-                continueParsing: () => {
-                    return continueAfterMatroskaParseResult({
-                        iterator,
-                        state,
-                        result: main,
-                        segment: newSegment,
-                    });
-                },
-                segment: newSegment,
-            };
+        return newSegment;
+    }
+    if (segmentId === all_segments_1.matroskaElements.Cluster) {
+        if (isInsideSegment === null) {
+            throw new Error('Expected to be inside segment');
         }
-        return {
-            status: 'done',
-            segment: newSegment,
+        state.webm.addCluster({
+            start: offset,
+            size,
+            segment: isInsideSegment.index,
+        });
+        const newSegment = {
+            type: 'Cluster',
+            minVintWidth: offsetAfterVInt - offsetBeforeVInt,
+            value: [],
         };
+        return newSegment;
     }
-    if (bytesRemainingNow < length) {
-        const bytesRead = iterator.counter.getOffset() - offset;
-        iterator.counter.decrement(bytesRead);
-        return {
-            status: 'incomplete',
-            segment: null,
-            continueParsing: () => {
-                return (0, exports.expectSegment)({
-                    iterator,
-                    state,
-                    offset,
-                    children,
-                    fields,
-                    topLevelStructure,
-                });
-            },
-        };
+    if (bytesRemainingNow < size) {
+        returnToCheckpoint();
+        return null;
     }
     const segment = await parseSegment({
         segmentId,
         iterator,
-        length,
+        length: size,
         state,
         headerReadSoFar: iterator.counter.getOffset() - offset,
     });
-    return {
-        status: 'done',
-        segment,
-    };
+    return segment;
 };
 exports.expectSegment = expectSegment;
 const parseSegment = async ({ segmentId, iterator, length, state, headerReadSoFar, }) => {

package/dist/buffer-iterator.d.ts

@@ -18,7 +18,6 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     peekB: (length: number) => void;
     peekD: (length: number) => void;
     getBits: (bits: number) => number;
-    byteLength: () => number;
     bytesRemaining: () => number;
     leb128: () => number;
     removeBytesRead: () => void;
@@ -58,8 +57,6 @@ export declare const getArrayBufferIterator: (initialData: Uint8Array, maxBytes:
     getInt32Le: () => number;
     getInt32: () => number;
     destroy: () => void;
-    disallowDiscard: () => void;
-    allowDiscard: () => void;
     startBox: (size: number) => {
         discardRest: () => void;
         expectNoMoreBytes: () => void;

package/dist/buffer-iterator.js

@@ -69,7 +69,6 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
     data.set(initialData);
     let view = new DataView(data.buffer);
     const counter = makeOffsetCounter();
-    let discardAllowed = true;
     const startCheckpoint = () => {
         const checkpoint = counter.getOffset();
         return {
@@ -83,12 +82,6 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         counter.increment(amount);
         return value;
     };
-    const disallowDiscard = () => {
-        discardAllowed = false;
-    };
-    const allowDiscard = () => {
-        discardAllowed = true;
-    };
     const discard = (length) => {
         counter.increment(length);
     };
@@ -199,22 +192,22 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
     const addData = (newData) => {
         const oldLength = buf.byteLength;
         const newLength = oldLength + newData.byteLength;
+        if (newLength < oldLength) {
+            throw new Error('Cannot decrement size');
+        }
+        if (newLength > (maxBytes !== null && maxBytes !== void 0 ? maxBytes : Infinity)) {
+            throw new Error(`Exceeded maximum byte length ${maxBytes} with ${newLength}`);
+        }
         buf.resize(newLength);
         const newArray = new Uint8Array(buf);
         newArray.set(newData, oldLength);
         data = newArray;
         view = new DataView(data.buffer);
     };
-    const byteLength = () => {
-        return data.byteLength;
-    };
     const bytesRemaining = () => {
         return data.byteLength - counter.getDiscardedOffset();
     };
     const removeBytesRead = () => {
-        if (!discardAllowed) {
-            return;
-        }
         const bytesToRemove = counter.getDiscardedOffset();
         // Only do this operation if it is really worth it 😇
         if (bytesToRemove < 100000) {
@@ -331,7 +324,6 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         peekB,
         peekD,
         getBits,
-        byteLength,
         bytesRemaining,
         leb128,
         removeBytesRead,
@@ -536,8 +528,6 @@ const getArrayBufferIterator = (initialData, maxBytes) => {
         getInt32Le,
         getInt32,
         destroy,
-        disallowDiscard,
-        allowDiscard,
         startBox,
         readExpGolomb,
         startCheckpoint,

package/dist/bun-reader.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bun-reader.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const example_videos_1 = require("@remotion/example-videos");
+const fs_1 = require("fs");
+const stream_1 = require("stream");
+const range = null;
+const stream = (0, fs_1.createReadStream)(example_videos_1.exampleVideos.framer24fps, {
+    start: range === null ? 0 : typeof range === 'number' ? range : range[0],
+    end: range === null ? Infinity : typeof range === 'number' ? Infinity : range[1],
+});
+const reader = stream_1.Readable.toWeb(stream).getReader();
+console.log(await reader.read());
+console.log(await reader.read());
+console.log(await reader.read());
+console.log(await reader.read());
+console.log(await reader.read());
+console.log(await reader.read());

package/dist/emit-available-info.js

@@ -156,7 +156,7 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
                 hasInfo.videoCodec &&
                 parseResult &&
                 segments) {
-                const videoCodec = (0, get_video_codec_1.getVideoCodec)(segments, state);
+                const videoCodec = (0, get_video_codec_1.getVideoCodec)(state);
                 (_m = callbacks.onVideoCodec) === null || _m === void 0 ? void 0 : _m.call(callbacks, videoCodec);
                 if (fieldsInReturnValue.videoCodec) {
                     returnValue.videoCodec = videoCodec;
@@ -170,7 +170,7 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
                 hasInfo.audioCodec &&
                 parseResult &&
                 segments) {
-                const audioCodec = (0, get_audio_codec_1.getAudioCodec)(segments, state);
+                const audioCodec = (0, get_audio_codec_1.getAudioCodec)(state);
                 (_o = callbacks.onAudioCodec) === null || _o === void 0 ? void 0 : _o.call(callbacks, audioCodec);
                 if (fieldsInReturnValue.audioCodec) {
                     returnValue.audioCodec = audioCodec;
@@ -181,7 +181,7 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
         }
         if (key === 'tracks') {
             if (!emittedFields.tracks && hasInfo.tracks && parseResult && segments) {
-                const { videoTracks, audioTracks } = (0, get_tracks_1.getTracks)(segments, state);
+                const { videoTracks, audioTracks } = (0, get_tracks_1.getTracks)(state);
                 (_p = callbacks.onTracks) === null || _p === void 0 ? void 0 : _p.call(callbacks, { videoTracks, audioTracks });
                 if (fieldsInReturnValue.tracks) {
                     returnValue.tracks = { videoTracks, audioTracks };
@@ -233,7 +233,7 @@ const emitAvailableInfo = ({ hasInfo, parseResult, callbacks, state, returnValue
         }
         if (key === 'isHdr') {
             if (!returnValue.isHdr && hasInfo.isHdr && parseResult && segments) {
-                const isHdr = (0, get_is_hdr_1.getIsHdr)(segments, state);
+                const isHdr = (0, get_is_hdr_1.getIsHdr)(state);
                 (_t = callbacks.onIsHdr) === null || _t === void 0 ? void 0 : _t.call(callbacks, isHdr);
                 if (fieldsInReturnValue.isHdr) {
                     returnValue.isHdr = isHdr;

package/dist/esm/from-node.mjs

@@ -1,10 +1,9 @@
 // src/readers/from-node.ts
-import { createReadStream } from "fs";
-import { stat } from "node:fs/promises";
+import { createReadStream, statSync } from "fs";
 import { sep } from "path";
 import { Readable } from "stream";
 var nodeReader = {
-  read: async (src, range, signal) => {
+  read: (src, range, signal) => {
     if (typeof src !== "string") {
       throw new Error("src must be a string when using `nodeReader`");
     }
@@ -17,7 +16,7 @@ var nodeReader = {
     signal?.addEventListener("abort", () => {
       controller.abort();
     }, { once: true });
-    const stats = await stat(src);
+    const stats = statSync(src);
     const reader = Readable.toWeb(stream).getReader();
     if (signal) {
       signal.addEventListener("abort", () => {
@@ -25,7 +24,7 @@ var nodeReader = {
         });
       }, { once: true });
     }
-    return {
+    return Promise.resolve({
       reader: {
         reader,
         abort: () => {
@@ -36,14 +35,14 @@ var nodeReader = {
       contentType: null,
       name: src.split(sep).pop(),
       supportsContentRange: true
-    };
+    });
   },
-  getLength: async (src) => {
+  getLength: (src) => {
     if (typeof src !== "string") {
       throw new Error("src must be a string when using `nodeReader`");
     }
-    const stats = await stat(src);
-    return stats.size;
+    const stats = statSync(src);
+    return Promise.resolve(stats.size);
   }
 };
 export {