@remotion/media-parser 4.0.256 → 4.0.257

package/dist/parse-video.js

@@ -1,39 +0,0 @@
-"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

@@ -1,10 +0,0 @@
-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

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

package/dist/parser-state.d.ts

@@ -1,22 +0,0 @@
-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

@@ -1,132 +0,0 @@
-"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/writers/buffer-implementation/writer.d.ts

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

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

@@ -1,54 +0,0 @@
-"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

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

package/dist/writers/buffer.js

@@ -1,7 +0,0 @@
-"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

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

package/dist/writers/web-fs.js

@@ -1,74 +0,0 @@
-"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;