@remotion/media-parser 4.0.241 → 4.0.243

package/dist/state/sample-callbacks.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sampleCallback = void 0;
+const need_samples_for_fields_1 = require("../may-skip-video-data/need-samples-for-fields");
+const can_skip_tracks_1 = require("./can-skip-tracks");
+const has_tracks_section_1 = require("./has-tracks-section");
+const sampleCallback = ({ signal, hasAudioTrackHandlers, hasVideoTrackHandlers, fields, keyframes, emittedFields, slowDurationAndFpsState, }) => {
+    const videoSampleCallbacks = {};
+    const audioSampleCallbacks = {};
+    const queuedAudioSamples = {};
+    const queuedVideoSamples = {};
+    const canSkipTracksState = (0, can_skip_tracks_1.makeCanSkipTracksState)({
+        hasAudioTrackHandlers,
+        fields,
+        hasVideoTrackHandlers,
+    });
+    const tracksState = (0, has_tracks_section_1.makeTracksSectionState)(canSkipTracksState);
+    const samplesForTrack = {};
+    return {
+        registerVideoSampleCallback: async (id, callback) => {
+            var _a;
+            if (callback === null) {
+                delete videoSampleCallbacks[id];
+                return;
+            }
+            videoSampleCallbacks[id] = callback;
+            for (const queued of (_a = queuedVideoSamples[id]) !== null && _a !== void 0 ? _a : []) {
+                await callback(queued);
+            }
+            queuedVideoSamples[id] = [];
+        },
+        onAudioSample: async (trackId, audioSample) => {
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new Error('Aborted');
+            }
+            if (typeof samplesForTrack[trackId] === 'undefined') {
+                samplesForTrack[trackId] = 0;
+            }
+            const callback = audioSampleCallbacks[trackId];
+            if (audioSample.data.length > 0) {
+                samplesForTrack[trackId]++;
+                // If we emit samples with data length 0, Chrome will fail
+                if (callback) {
+                    await callback(audioSample);
+                }
+            }
+        },
+        getSamplesForTrack: (trackId) => {
+            var _a;
+            return (_a = samplesForTrack[trackId]) !== null && _a !== void 0 ? _a : 0;
+        },
+        onVideoSample: async (trackId, videoSample) => {
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new Error('Aborted');
+            }
+            if (typeof samplesForTrack[trackId] === 'undefined') {
+                samplesForTrack[trackId] = 0;
+            }
+            if (videoSample.data.length > 0) {
+                samplesForTrack[trackId]++;
+                const callback = videoSampleCallbacks[trackId];
+                // If we emit samples with data 0, Chrome will fail
+                if (callback) {
+                    await callback(videoSample);
+                }
+            }
+            if ((0, need_samples_for_fields_1.needsToIterateOverSamples)({
+                fields,
+                emittedFields,
+            })) {
+                if (fields.slowKeyframes && videoSample.type === 'key') {
+                    keyframes.addKeyframe({
+                        trackId,
+                        decodingTimeInSeconds: videoSample.dts / videoSample.timescale,
+                        positionInBytes: videoSample.offset,
+                        presentationTimeInSeconds: videoSample.cts / videoSample.timescale,
+                        sizeInBytes: videoSample.data.length,
+                    });
+                }
+                slowDurationAndFpsState.addSample(videoSample);
+            }
+        },
+        canSkipTracksState,
+        registerAudioSampleCallback: async (id, callback) => {
+            var _a;
+            if (callback === null) {
+                delete audioSampleCallbacks[id];
+                return;
+            }
+            audioSampleCallbacks[id] = callback;
+            for (const queued of (_a = queuedAudioSamples[id]) !== null && _a !== void 0 ? _a : []) {
+                await callback(queued);
+            }
+            queuedAudioSamples[id] = [];
+        },
+        tracks: tracksState,
+        audioSampleCallbacks,
+        videoSampleCallbacks,
+    };
+};
+exports.sampleCallback = sampleCallback;

package/dist/state/slow-duration-fps.d.ts

@@ -0,0 +1,8 @@
+import type { AudioOrVideoSample } from '../webcodec-sample-types';
+export declare const slowDurationAndFpsState: () => {
+    addSample: (videoSample: AudioOrVideoSample) => void;
+    getSlowDurationInSeconds: () => number;
+    getFps: () => number;
+    getSlowNumberOfFrames: () => number;
+};
+export type SlowDurationAndFpsState = ReturnType<typeof slowDurationAndFpsState>;

package/dist/state/slow-duration-fps.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slowDurationAndFpsState = void 0;
+const slowDurationAndFpsState = () => {
+    let smallestSample;
+    let largestSample;
+    let samples = 0;
+    const getSlowDurationInSeconds = () => {
+        if (smallestSample !== undefined && largestSample !== undefined) {
+            const startingTimestampDifference = largestSample - smallestSample;
+            const timeBetweenSamples = startingTimestampDifference / (samples - 1);
+            return timeBetweenSamples * samples;
+        }
+        throw new Error('No samples');
+    };
+    return {
+        addSample: (videoSample) => {
+            samples++;
+            const presentationTimeInSeconds = videoSample.cts / videoSample.timescale;
+            if (largestSample === undefined ||
+                presentationTimeInSeconds > largestSample) {
+                largestSample = presentationTimeInSeconds;
+            }
+            if (smallestSample === undefined ||
+                presentationTimeInSeconds < smallestSample) {
+                smallestSample = presentationTimeInSeconds;
+            }
+        },
+        getSlowDurationInSeconds,
+        getFps: () => {
+            return samples / getSlowDurationInSeconds();
+        },
+        getSlowNumberOfFrames: () => samples,
+    };
+};
+exports.slowDurationAndFpsState = slowDurationAndFpsState;

package/dist/state/structure.d.ts

@@ -0,0 +1,7 @@
+import type { Structure } from '../parse-result';
+export declare const structureState: () => {
+    getStructureOrNull: () => Structure | null;
+    getStructure: () => Structure;
+    setStructure: (value: Structure) => void;
+};
+export type StructureState = ReturnType<typeof structureState>;

package/dist/state/structure.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.structureState = void 0;
+const structureState = () => {
+    let structure = null;
+    return {
+        getStructureOrNull: () => {
+            return structure;
+        },
+        getStructure: () => {
+            if (structure === null) {
+                throw new Error('Expected structure');
+            }
+            return structure;
+        },
+        setStructure: (value) => {
+            structure = value;
+        },
+    };
+};
+exports.structureState = structureState;

package/dist/state/tracks-and-samples.js

@@ -0,0 +1 @@
+"use strict";

package/dist/state/webm.d.ts

@@ -0,0 +1,11 @@
+import type { OnTrackEntrySegment } from '../boxes/webm/segments';
+import type { TrackInfo } from '../boxes/webm/segments/track-entry';
+export declare const webmState: () => {
+    onTrackEntrySegment: OnTrackEntrySegment;
+    getTrackInfoByNumber: (id: number) => TrackInfo;
+    setTimestampOffset: (byteOffset: number, timestamp: number) => void;
+    getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
+    timescale: null;
+    getTimescale: () => number;
+    setTimescale: (newTimescale: number) => void;
+};

package/dist/state/webm.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webmState = void 0;
+const traversal_1 = require("../boxes/webm/traversal");
+const webmState = () => {
+    const trackEntries = {};
+    const onTrackEntrySegment = (trackEntry) => {
+        var _a;
+        const trackId = (0, traversal_1.getTrackId)(trackEntry);
+        if (!trackId) {
+            throw new Error('Expected track id');
+        }
+        if (trackEntries[trackId]) {
+            return;
+        }
+        const codec = (0, traversal_1.getTrackCodec)(trackEntry);
+        if (!codec) {
+            throw new Error('Expected codec');
+        }
+        const trackTimescale = (0, traversal_1.getTrackTimestampScale)(trackEntry);
+        trackEntries[trackId] = {
+            codec: codec.value,
+            trackTimescale: (_a = trackTimescale === null || trackTimescale === void 0 ? void 0 : trackTimescale.value) !== null && _a !== void 0 ? _a : null,
+        };
+    };
+    const timestampMap = new Map();
+    const getTimestampOffsetForByteOffset = (byteOffset) => {
+        const entries = Array.from(timestampMap.entries());
+        const sortedByByteOffset = entries
+            .sort((a, b) => {
+            return a[0] - b[0];
+        })
+            .reverse();
+        for (const [offset, timestamp] of sortedByByteOffset) {
+            if (offset >= byteOffset) {
+                continue;
+            }
+            return timestamp;
+        }
+        return timestampMap.get(byteOffset);
+    };
+    const setTimestampOffset = (byteOffset, timestamp) => {
+        timestampMap.set(byteOffset, timestamp);
+    };
+    let timescale = null;
+    const setTimescale = (newTimescale) => {
+        timescale = newTimescale;
+    };
+    const getTimescale = () => {
+        // https://www.matroska.org/technical/notes.html
+        // When using the default value of TimestampScale of “1,000,000”, one Segment Tick represents one millisecond.
+        if (timescale === null) {
+            return 1000000;
+        }
+        return timescale;
+    };
+    return {
+        onTrackEntrySegment,
+        getTrackInfoByNumber: (id) => trackEntries[id],
+        setTimestampOffset,
+        getTimestampOffsetForByteOffset,
+        timescale,
+        getTimescale,
+        setTimescale,
+    };
+};
+exports.webmState = webmState;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.241";
+export declare const VERSION = "4.0.243";

package/dist/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // Automatically generated on publish
-exports.VERSION = '4.0.241';
+exports.VERSION = '4.0.243';

package/dist/webcodec-sample-types.d.ts

@@ -18,4 +18,6 @@ export type AudioOrVideoSample = {
     type: 'key' | 'delta';
     cts: number;
     dts: number;
+    offset: number;
+    timescale: number;
 };

package/package.json

@@ -3,14 +3,14 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/media-parser"
   },
   "name": "@remotion/media-parser",
-  "version": "4.0.241",
+  "version": "4.0.243",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
     "@types/wicg-file-system-access": "2023.10.5",
     "eslint": "9.14.0",
-    "@remotion/example-videos": "4.0.241",
-    "@remotion/eslint-config-internal": "4.0.241"
+    "@remotion/example-videos": "4.0.243",
+    "@remotion/eslint-config-internal": "4.0.243"
   },
   "publishConfig": {
     "access": "public"