@remotion/media-parser 4.0.255 → 4.0.256

package/dist/parse-video.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVideo = void 0;
+const process_box_1 = require("./boxes/iso-base-media/process-box");
+const parse_box_1 = require("./boxes/riff/parse-box");
+const parse_webm_header_1 = require("./boxes/webm/parse-webm-header");
+const log_1 = require("./log");
+const parseVideo = ({ iterator, options, signal, logLevel, fields, }) => {
+    if (iterator.bytesRemaining() === 0) {
+        return Promise.reject(new Error('no bytes'));
+    }
+    if (iterator.isRiff()) {
+        log_1.Log.verbose(logLevel, 'Detected RIFF container');
+        return Promise.resolve((0, parse_box_1.parseRiff)({ iterator, options, fields }));
+    }
+    if (iterator.isIsoBaseMedia()) {
+        log_1.Log.verbose(logLevel, 'Detected ISO Base Media container');
+        return (0, process_box_1.parseIsoBaseMediaBoxes)({
+            iterator,
+            maxBytes: Infinity,
+            allowIncompleteBoxes: true,
+            initialBoxes: [],
+            options,
+            continueMdat: false,
+            signal,
+            logLevel,
+            fields,
+        });
+    }
+    if (iterator.isWebm()) {
+        log_1.Log.verbose(logLevel, 'Detected Matroska container');
+        return (0, parse_webm_header_1.parseWebm)({ counter: iterator, parserContext: options, fields });
+    }
+    if (iterator.isMp3()) {
+        return Promise.reject(new Error('MP3 files are not yet supported'));
+    }
+    return Promise.reject(new Error('Unknown video format'));
+};
+exports.parseVideo = parseVideo;

package/dist/parser-context.d.ts

@@ -0,0 +1,10 @@
+import type { ParserState } from './state/parser-state';
+import type { OnAudioTrack, OnVideoTrack } from './webcodec-sample-types';
+export type ParserContext = {
+    onAudioTrack: OnAudioTrack | null;
+    onVideoTrack: OnVideoTrack | null;
+    parserState: ParserState;
+    nullifySamples: boolean;
+    supportsContentRange: boolean;
+    nextTrackIndex: number;
+};

package/dist/parser-context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/parser-state.d.ts

@@ -0,0 +1,22 @@
+import type { OnTrackEntrySegment } from './boxes/webm/segments';
+import type { TrackInfo } from './boxes/webm/segments/track-entry';
+import type { AudioSample, OnAudioSample, OnVideoSample, VideoSample } from './webcodec-sample-types';
+export type InternalStats = {};
+export declare const makeParserState: ({ hasAudioCallbacks, hasVideoCallbacks, signal, }: {
+    hasAudioCallbacks: boolean;
+    hasVideoCallbacks: boolean;
+    signal: AbortSignal | undefined;
+}) => {
+    onTrackEntrySegment: OnTrackEntrySegment;
+    getTrackInfoByNumber: (id: number) => TrackInfo;
+    registerVideoSampleCallback: (id: number, callback: OnVideoSample | null) => Promise<void>;
+    setTimestampOffset: (byteOffset: number, timestamp: number) => void;
+    getTimestampOffsetForByteOffset: (byteOffset: number) => number | undefined;
+    registerAudioSampleCallback: (id: number, callback: OnAudioSample | null) => Promise<void>;
+    onAudioSample: (trackId: number, audioSample: AudioSample) => Promise<void>;
+    onVideoSample: (trackId: number, videoSample: VideoSample) => Promise<void>;
+    getInternalStats: () => {};
+    getTimescale: () => number;
+    setTimescale: (newTimescale: number) => void;
+};
+export type ParserState = ReturnType<typeof makeParserState>;

package/dist/parser-state.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeParserState = void 0;
+const traversal_1 = require("./boxes/webm/traversal");
+const makeParserState = ({ hasAudioCallbacks, hasVideoCallbacks, signal, }) => {
+    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 videoSampleCallbacks = {};
+    const audioSampleCallbacks = {};
+    const queuedAudioSamples = {};
+    const queuedVideoSamples = {};
+    const declinedTrackNumbers = [];
+    let timescale = null;
+    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;
+    };
+    const setTimescale = (newTimescale) => {
+        timescale = newTimescale;
+    };
+    const timestampMap = new Map();
+    const setTimestampOffset = (byteOffset, timestamp) => {
+        timestampMap.set(byteOffset, timestamp);
+    };
+    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);
+    };
+    return {
+        onTrackEntrySegment,
+        getTrackInfoByNumber: (id) => trackEntries[id],
+        registerVideoSampleCallback: async (id, callback) => {
+            var _a;
+            if (callback === null) {
+                delete videoSampleCallbacks[id];
+                declinedTrackNumbers.push(id);
+                return;
+            }
+            videoSampleCallbacks[id] = callback;
+            for (const queued of (_a = queuedVideoSamples[id]) !== null && _a !== void 0 ? _a : []) {
+                await callback(queued);
+            }
+            queuedVideoSamples[id] = [];
+        },
+        setTimestampOffset,
+        getTimestampOffsetForByteOffset,
+        registerAudioSampleCallback: async (id, callback) => {
+            var _a;
+            if (callback === null) {
+                delete audioSampleCallbacks[id];
+                declinedTrackNumbers.push(id);
+                return;
+            }
+            audioSampleCallbacks[id] = callback;
+            for (const queued of (_a = queuedAudioSamples[id]) !== null && _a !== void 0 ? _a : []) {
+                await callback(queued);
+            }
+            queuedAudioSamples[id] = [];
+        },
+        onAudioSample: async (trackId, audioSample) => {
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new Error('Aborted');
+            }
+            const callback = audioSampleCallbacks[trackId];
+            if (callback) {
+                await callback(audioSample);
+            }
+            else {
+                if (declinedTrackNumbers.includes(trackId)) {
+                    return;
+                }
+                if (!hasAudioCallbacks) {
+                    throw new Error('No audio callbacks registered');
+                }
+            }
+        },
+        onVideoSample: async (trackId, videoSample) => {
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new Error('Aborted');
+            }
+            const callback = videoSampleCallbacks[trackId];
+            if (callback) {
+                await callback(videoSample);
+            }
+            else {
+                if (declinedTrackNumbers.includes(trackId)) {
+                    return;
+                }
+                if (!hasVideoCallbacks) {
+                    throw new Error('No video callbacks registered');
+                }
+            }
+        },
+        getInternalStats: () => ({}),
+        getTimescale,
+        setTimescale,
+    };
+};
+exports.makeParserState = makeParserState;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "4.0.255";
+export declare const VERSION = "4.0.256";

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.255';
+exports.VERSION = '4.0.256';

package/dist/writers/buffer-implementation/writer.d.ts

@@ -0,0 +1,2 @@
+import type { CreateContent } from '../writer';
+export declare const createContent: CreateContent;

package/dist/writers/buffer-implementation/writer.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContent = void 0;
+const createContent = ({ filename, mimeType }) => {
+    const buf = new ArrayBuffer(0, {
+        // TODO: Educate that the buffer is limited to 2GB
+        maxByteLength: 2000000000,
+    });
+    if (!buf.resize) {
+        throw new Error('Could not create buffer writer');
+    }
+    const write = (newData) => {
+        const oldLength = buf.byteLength;
+        const newLength = oldLength + newData.byteLength;
+        buf.resize(newLength);
+        const newArray = new Uint8Array(buf);
+        newArray.set(newData, oldLength);
+    };
+    const updateDataAt = (position, newData) => {
+        const newArray = new Uint8Array(buf);
+        newArray.set(newData, position);
+    };
+    let writPromise = Promise.resolve();
+    let removed = false;
+    const writer = {
+        write: (arr) => {
+            writPromise = writPromise.then(() => write(arr));
+            return writPromise;
+        },
+        save: () => {
+            if (removed) {
+                return Promise.reject(new Error('Already called .remove() on the result'));
+            }
+            const arr = new Uint8Array(buf);
+            return Promise.resolve(
+            // TODO: Unhardcode MIME type and file name
+            new File([arr.slice()], filename, { type: mimeType }));
+        },
+        remove() {
+            removed = true;
+            return Promise.resolve();
+        },
+        getWrittenByteCount: () => buf.byteLength,
+        updateDataAt: (position, newData) => {
+            writPromise = writPromise.then(() => updateDataAt(position, newData));
+            return writPromise;
+        },
+        waitForFinish: async () => {
+            await writPromise;
+        },
+    };
+    return Promise.resolve(writer);
+};
+exports.createContent = createContent;

package/dist/writers/buffer.d.ts

@@ -0,0 +1,2 @@
+import type { WriterInterface } from './writer';
+export declare const bufferWriter: WriterInterface;

package/dist/writers/buffer.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferWriter = void 0;
+const writer_1 = require("./buffer-implementation/writer");
+exports.bufferWriter = {
+    createContent: writer_1.createContent,
+};

package/dist/writers/web-fs.d.ts

@@ -0,0 +1,3 @@
+import type { WriterInterface } from './writer';
+export declare const webFsWriter: WriterInterface;
+export declare const canUseWebFsWriter: () => Promise<boolean>;

package/dist/writers/web-fs.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canUseWebFsWriter = exports.webFsWriter = void 0;
+const createContent = async ({ filename }) => {
+    const directoryHandle = await navigator.storage.getDirectory();
+    directoryHandle.removeEntry(filename);
+    const fileHandle = await directoryHandle.getFileHandle(filename, {
+        create: true,
+    });
+    const writable = await fileHandle.createWritable();
+    let written = 0;
+    let writPromise = Promise.resolve();
+    const write = async (arr) => {
+        await writable.write(arr);
+        written += arr.byteLength;
+    };
+    const updateDataAt = async (position, data) => {
+        await writable.seek(position);
+        await writable.write(data);
+        await writable.seek(written);
+    };
+    const remove = async () => {
+        await directoryHandle.removeEntry(filename, {
+            recursive: true,
+        });
+    };
+    const writer = {
+        write: (arr) => {
+            writPromise = writPromise.then(() => write(arr));
+            return writPromise;
+        },
+        save: async () => {
+            try {
+                await writable.close();
+            }
+            catch (_a) {
+                // Ignore, could already be closed
+            }
+            const newHandle = await directoryHandle.getFileHandle(filename, {
+                create: true,
+            });
+            const newFile = await newHandle.getFile();
+            return newFile;
+        },
+        getWrittenByteCount: () => written,
+        updateDataAt: (position, data) => {
+            writPromise = writPromise.then(() => updateDataAt(position, data));
+            return writPromise;
+        },
+        waitForFinish: async () => {
+            await writPromise;
+        },
+        remove,
+    };
+    return writer;
+};
+exports.webFsWriter = {
+    createContent,
+};
+const canUseWebFsWriter = async () => {
+    if (!('storage' in navigator)) {
+        return false;
+    }
+    if (!('getDirectory' in navigator.storage)) {
+        return false;
+    }
+    const directoryHandle = await navigator.storage.getDirectory();
+    const fileHandle = await directoryHandle.getFileHandle('remotion-probe-web-fs-support', {
+        create: true,
+    });
+    const canUse = fileHandle.createWritable !== undefined;
+    return canUse;
+};
+exports.canUseWebFsWriter = canUseWebFsWriter;

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.255",
+  "version": "4.0.256",
   "main": "dist/index.js",
   "sideEffects": false,
   "devDependencies": {
     "@types/wicg-file-system-access": "2023.10.5",
     "eslint": "9.14.0",
-    "@remotion/example-videos": "4.0.255",
-    "@remotion/eslint-config-internal": "4.0.255"
+    "@remotion/example-videos": "4.0.256",
+    "@remotion/eslint-config-internal": "4.0.256"
   },
   "publishConfig": {
     "access": "public"

package/dist/abort.d.ts

@@ -1 +0,0 @@
-export declare const hasBeenAborted: (error: unknown) => error is MediaParserAbortError;

package/dist/abort.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasBeenAborted = void 0;
-const hasBeenAborted = (error) => {
-    return error instanceof MediaParserAbortError;
-};
-exports.hasBeenAborted = hasBeenAborted;

package/dist/controller.d.ts

@@ -1,17 +0,0 @@
-import { MediaParserEmitter } from './emitter';
-import type { PauseSignal } from './pause-signal';
-export type MediaParserController = {
-    abort: (reason?: any) => void;
-    pause: PauseSignal['pause'];
-    resume: PauseSignal['resume'];
-    addEventListener: MediaParserEmitter['addEventListener'];
-    removeEventListener: MediaParserEmitter['removeEventListener'];
-    /**
-     * @deprecated Not public API
-     */
-    _internals: {
-        signal: AbortSignal;
-        checkForAbortAndPause: () => Promise<void>;
-    };
-};
-export declare const mediaParserController: () => MediaParserController;

package/dist/controller.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mediaParserController = void 0;
-const emitter_1 = require("./emitter");
-const pause_signal_1 = require("./pause-signal");
-const mediaParserController = () => {
-    const abortController = new AbortController();
-    const emitter = new emitter_1.MediaParserEmitter();
-    const pauseSignal = (0, pause_signal_1.makePauseSignal)(emitter);
-    const checkForAbortAndPause = async () => {
-        if (abortController.signal.aborted) {
-            throw new Error('Aborted');
-        }
-        await pauseSignal.waitUntilResume();
-    };
-    return {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        abort: (reason) => {
-            abortController.abort(reason);
-        },
-        pause: pauseSignal.pause,
-        resume: pauseSignal.resume,
-        addEventListener: emitter.addEventListener,
-        removeEventListener: emitter.removeEventListener,
-        _internals: {
-            signal: abortController.signal,
-            checkForAbortAndPause,
-        },
-    };
-};
-exports.mediaParserController = mediaParserController;

package/dist/parse-and-download-media.d.ts

@@ -1,2 +0,0 @@
-import type { DownloadAndParseMedia } from './options';
-export declare const parseAndDownloadMedia: DownloadAndParseMedia;

package/dist/parse-and-download-media.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseAndDownloadMedia = void 0;
-const internal_parse_media_1 = require("./internal-parse-media");
-const from_fetch_1 = require("./readers/from-fetch");
-const parseAndDownloadMedia = async (options) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8;
-    const content = await options.writer.createContent({
-        filename: 'hmm',
-        mimeType: 'shouldnotmatter',
-    });
-    const returnValue = await (0, internal_parse_media_1.internalParseMedia)({
-        fields: (_a = options.fields) !== null && _a !== void 0 ? _a : null,
-        logLevel: (_b = options.logLevel) !== null && _b !== void 0 ? _b : 'info',
-        mode: 'download',
-        onAudioCodec: (_c = options.onAudioCodec) !== null && _c !== void 0 ? _c : null,
-        onAudioTrack: null,
-        onContainer: (_d = options.onContainer) !== null && _d !== void 0 ? _d : null,
-        onDimensions: (_e = options.onDimensions) !== null && _e !== void 0 ? _e : null,
-        onDiscardedData: async (data) => {
-            await content.write(data);
-        },
-        onDurationInSeconds: (_f = options.onDurationInSeconds) !== null && _f !== void 0 ? _f : null,
-        onFps: (_g = options.onFps) !== null && _g !== void 0 ? _g : null,
-        onImages: (_h = options.onImages) !== null && _h !== void 0 ? _h : null,
-        onInternalStats: (_j = options.onInternalStats) !== null && _j !== void 0 ? _j : null,
-        onIsHdr: (_k = options.onIsHdr) !== null && _k !== void 0 ? _k : null,
-        onKeyframes: (_l = options.onKeyframes) !== null && _l !== void 0 ? _l : null,
-        onLocation: (_m = options.onLocation) !== null && _m !== void 0 ? _m : null,
-        onMetadata: (_o = options.onMetadata) !== null && _o !== void 0 ? _o : null,
-        onMimeType: (_p = options.onMimeType) !== null && _p !== void 0 ? _p : null,
-        onName: (_q = options.onName) !== null && _q !== void 0 ? _q : null,
-        onNumberOfAudioChannels: (_r = options.onNumberOfAudioChannels) !== null && _r !== void 0 ? _r : null,
-        onParseProgress: (_s = options.onParseProgress) !== null && _s !== void 0 ? _s : null,
-        onRotation: (_t = options.onRotation) !== null && _t !== void 0 ? _t : null,
-        onSampleRate: (_u = options.onSampleRate) !== null && _u !== void 0 ? _u : null,
-        onSize: (_v = options.onSize) !== null && _v !== void 0 ? _v : null,
-        onSlowAudioBitrate: (_w = options.onSlowAudioBitrate) !== null && _w !== void 0 ? _w : null,
-        onSlowDurationInSeconds: (_x = options.onSlowDurationInSeconds) !== null && _x !== void 0 ? _x : null,
-        onSlowFps: (_y = options.onSlowFps) !== null && _y !== void 0 ? _y : null,
-        onSlowKeyframes: (_z = options.onSlowKeyframes) !== null && _z !== void 0 ? _z : null,
-        onSlowNumberOfFrames: (_0 = options.onSlowNumberOfFrames) !== null && _0 !== void 0 ? _0 : null,
-        onSlowVideoBitrate: (_1 = options.onSlowVideoBitrate) !== null && _1 !== void 0 ? _1 : null,
-        onStructure: (_2 = options.onStructure) !== null && _2 !== void 0 ? _2 : null,
-        onTracks: (_3 = options.onTracks) !== null && _3 !== void 0 ? _3 : null,
-        onUnrotatedDimensions: (_4 = options.onUnrotatedDimensions) !== null && _4 !== void 0 ? _4 : null,
-        onVideoCodec: (_5 = options.onVideoCodec) !== null && _5 !== void 0 ? _5 : null,
-        onVideoTrack: null,
-        progressIntervalInMs: (_6 = options.progressIntervalInMs) !== null && _6 !== void 0 ? _6 : null,
-        reader: (_7 = options.reader) !== null && _7 !== void 0 ? _7 : from_fetch_1.fetchReader,
-        signal: (_8 = options.signal) !== null && _8 !== void 0 ? _8 : undefined,
-        src: options.src,
-    });
-    await content.finish();
-    return returnValue;
-};
-exports.parseAndDownloadMedia = parseAndDownloadMedia;