@remotion/media-parser 4.0.244 → 4.0.246

package/dist/create/matroska/matroska-trackentry.js

@@ -1,249 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeMatroskaTracks = exports.makeMatroskaVideoTrackEntryBytes = exports.makeMatroskaAudioTrackEntryBytes = exports.makeMatroskaVideoBytes = void 0;
-const color_1 = require("../../boxes/webm/color");
-const make_header_1 = require("../../boxes/webm/make-header");
-const makeMatroskaVideoBytes = ({ color, width, height, }) => {
-    return (0, make_header_1.makeMatroskaBytes)({
-        type: 'Video',
-        value: [
-            {
-                type: 'PixelWidth',
-                value: {
-                    value: width,
-                    byteLength: null,
-                },
-                minVintWidth: null,
-            },
-            {
-                type: 'PixelHeight',
-                value: {
-                    value: height,
-                    byteLength: null,
-                },
-                minVintWidth: null,
-            },
-            {
-                type: 'FlagInterlaced',
-                value: {
-                    // https://datatracker.ietf.org/doc/draft-ietf-cellar-matroska/
-                    // 5.1.4.1.28.1.
-                    value: 2, // 2 - progressive, no interlaced
-                    byteLength: null,
-                },
-                minVintWidth: null,
-            },
-            (0, color_1.makeMatroskaColorBytes)(color),
-        ],
-        minVintWidth: null,
-    });
-};
-exports.makeMatroskaVideoBytes = makeMatroskaVideoBytes;
-const makeVideoCodecId = (codecId) => {
-    if (codecId === 'vp8') {
-        return 'V_VP8';
-    }
-    if (codecId === 'vp9') {
-        return 'V_VP9';
-    }
-    if (codecId === 'h264') {
-        return 'V_MPEG4/ISO/AVC';
-    }
-    if (codecId === 'av1') {
-        return 'V_AV1';
-    }
-    if (codecId === 'h265') {
-        return 'V_MPEGH/ISO/HEVC';
-    }
-    if (codecId === 'prores') {
-        return 'V_PRORES';
-    }
-    throw new Error(`Unknown codec: ${codecId}`);
-};
-const makeAudioCodecId = (codecId) => {
-    if (codecId === 'opus') {
-        return 'A_OPUS';
-    }
-    if (codecId === 'aac') {
-        return 'A_AAC';
-    }
-    if (codecId === 'mp3') {
-        return 'A_MPEG/L3';
-    }
-    if (codecId === 'vorbis') {
-        return 'A_VORBIS';
-    }
-    if (codecId === 'pcm-u8') {
-        return 'A_PCM/INT/LIT';
-    }
-    if (codecId === 'pcm-s16') {
-        return 'A_PCM/INT/LIT';
-    }
-    if (codecId === 'pcm-s24') {
-        return 'A_PCM/INT/LIT';
-    }
-    if (codecId === 'pcm-s32') {
-        return 'A_PCM/INT/LIT';
-    }
-    if (codecId === 'pcm-f32') {
-        return 'A_PCM/INT/LIT';
-    }
-    if (codecId === 'aiff') {
-        throw new Error('aiff is not supported in Matroska');
-    }
-    throw new Error(`Unknown codec: ${codecId}`);
-};
-const makeMatroskaAudioTrackEntryBytes = ({ trackNumber, codec, numberOfChannels, sampleRate, codecPrivate, }) => {
-    return (0, make_header_1.makeMatroskaBytes)({
-        type: 'TrackEntry',
-        minVintWidth: null,
-        value: [
-            {
-                type: 'TrackNumber',
-                value: {
-                    value: trackNumber,
-                    byteLength: null,
-                },
-                minVintWidth: null,
-            },
-            {
-                type: 'TrackUID',
-                value: '0x188FEB95C8EFABA',
-                minVintWidth: null,
-            },
-            {
-                type: 'TrackType',
-                value: {
-                    value: 2,
-                    byteLength: null,
-                },
-                minVintWidth: null,
-            },
-            {
-                type: 'CodecID',
-                value: makeAudioCodecId(codec),
-                minVintWidth: null,
-            },
-            {
-                type: 'Audio',
-                value: [
-                    {
-                        type: 'Channels',
-                        minVintWidth: null,
-                        value: {
-                            value: numberOfChannels,
-                            byteLength: null,
-                        },
-                    },
-                    {
-                        type: 'SamplingFrequency',
-                        minVintWidth: null,
-                        value: {
-                            value: sampleRate,
-                            size: '64',
-                        },
-                    },
-                    {
-                        type: 'BitDepth',
-                        minVintWidth: null,
-                        value: {
-                            value: 32,
-                            byteLength: null,
-                        },
-                    },
-                ],
-                minVintWidth: null,
-            },
-            codecPrivate
-                ? {
-                    type: 'CodecPrivate',
-                    minVintWidth: null,
-                    value: codecPrivate,
-                }
-                : null,
-        ].filter(Boolean),
-    });
-};
-exports.makeMatroskaAudioTrackEntryBytes = makeMatroskaAudioTrackEntryBytes;
-const makeMatroskaVideoTrackEntryBytes = ({ color, width, height, trackNumber, codec, codecPrivate, }) => {
-    return (0, make_header_1.makeMatroskaBytes)({
-        type: 'TrackEntry',
-        minVintWidth: null,
-        value: [
-            {
-                type: 'TrackNumber',
-                value: {
-                    value: trackNumber,
-                    byteLength: null,
-                },
-                minVintWidth: null,
-            },
-            {
-                type: 'TrackUID',
-                value: '0xab2171012bb9020a',
-                minVintWidth: null,
-            },
-            {
-                type: 'FlagLacing',
-                value: {
-                    value: 0,
-                    byteLength: null,
-                },
-                minVintWidth: null,
-            },
-            {
-                type: 'Language',
-                value: 'und',
-                minVintWidth: null,
-            },
-            {
-                type: 'FlagDefault',
-                value: {
-                    value: 0,
-                    byteLength: null,
-                },
-                minVintWidth: null,
-            },
-            {
-                type: 'CodecID',
-                value: makeVideoCodecId(codec),
-                minVintWidth: null,
-            },
-            {
-                type: 'TrackType',
-                value: {
-                    value: 1, // 'video'
-                    byteLength: null,
-                },
-                minVintWidth: null,
-            },
-            (0, exports.makeMatroskaVideoBytes)({
-                color,
-                width,
-                height,
-            }),
-            codecPrivate
-                ? {
-                    type: 'CodecPrivate',
-                    minVintWidth: null,
-                    value: codecPrivate,
-                }
-                : null,
-        ].filter(Boolean),
-    });
-};
-exports.makeMatroskaVideoTrackEntryBytes = makeMatroskaVideoTrackEntryBytes;
-const makeMatroskaTracks = (tracks) => {
-    const bytesArr = tracks.map((t) => {
-        const bytes = t.type === 'video'
-            ? (0, exports.makeMatroskaVideoTrackEntryBytes)(t)
-            : (0, exports.makeMatroskaAudioTrackEntryBytes)(t);
-        return bytes;
-    });
-    return (0, make_header_1.padMatroskaBytes)((0, make_header_1.makeMatroskaBytes)({
-        type: 'Tracks',
-        value: bytesArr,
-        minVintWidth: null,
-    }), 500);
-};
-exports.makeMatroskaTracks = makeMatroskaTracks;

package/dist/create/media-fn.d.ts

@@ -1,32 +0,0 @@
-import type { LogLevel } from '../log';
-import type { AudioOrVideoSample } from '../webcodec-sample-types';
-import type { WriterInterface } from '../writers/writer';
-import type { MakeTrackAudio, MakeTrackVideo } from './make-track-info';
-import type { ProgressTracker } from './progress-tracker';
-export type MediaFn = {
-    save: () => Promise<Blob>;
-    remove: () => Promise<void>;
-    addSample: (options: {
-        chunk: AudioOrVideoSample;
-        trackNumber: number;
-        isVideo: boolean;
-        codecPrivate: Uint8Array | null;
-    }) => Promise<void>;
-    addTrack: (track: Omit<MakeTrackAudio, 'trackNumber'> | Omit<MakeTrackVideo, 'trackNumber'>) => Promise<{
-        trackNumber: number;
-    }>;
-    addWaitForFinishPromise: (promise: () => Promise<void>) => void;
-    waitForFinish: () => Promise<void>;
-    updateTrackSampleRate: (options: {
-        trackNumber: number;
-        sampleRate: number;
-    }) => void;
-};
-export type MediaFnGeneratorInput = {
-    writer: WriterInterface;
-    onBytesProgress: (totalBytes: number) => void;
-    onMillisecondsProgress: (totalMilliseconds: number) => void;
-    logLevel: LogLevel;
-    filename: string;
-    progressTracker: ProgressTracker;
-};

package/dist/create/media-fn.js

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

package/dist/create/progress-tracker.d.ts

@@ -1,9 +0,0 @@
-export declare const makeProgressTracker: () => {
-    registerTrack: (trackNumber: number) => void;
-    getSmallestProgress: () => number;
-    updateTrackProgress: (trackNumber: number, progress: number) => void;
-    waitForProgress: () => Promise<void>;
-    getStartingTimestamp: () => number;
-    setPossibleLowestTimestamp: (timestamp: number) => void;
-};
-export type ProgressTracker = ReturnType<typeof makeProgressTracker>;

package/dist/create/progress-tracker.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeProgressTracker = void 0;
-const event_emitter_1 = require("./event-emitter");
-const with_resolvers_1 = require("./with-resolvers");
-// Make sure to distinguish null and undefined here
-const makeProgressTracker = () => {
-    const trackNumberProgresses = {};
-    const eventEmitter = new event_emitter_1.IoEventEmitter();
-    let startingTimestamp = null;
-    const setPossibleLowestTimestamp = (timestamp) => {
-        if (startingTimestamp === null) {
-            startingTimestamp = timestamp;
-        }
-        else {
-            startingTimestamp = Math.min(startingTimestamp, timestamp);
-        }
-    };
-    const getStartingTimestamp = () => {
-        if (startingTimestamp === null) {
-            throw new Error('No starting timestamp');
-        }
-        return startingTimestamp;
-    };
-    const calculateSmallestProgress = () => {
-        const progressValues = Object.values(trackNumberProgresses).map((p) => {
-            if (p !== null) {
-                return p;
-            }
-            // The starting timestamp might not be 0, it might be very huge
-            // If no sample has arrived yet, we should assume the smallest value
-            // we know as the progress
-            if (startingTimestamp === null) {
-                throw new Error('No progress values to calculate smallest progress from');
-            }
-            return startingTimestamp;
-        });
-        return Math.min(...progressValues);
-    };
-    return {
-        registerTrack: (trackNumber) => {
-            trackNumberProgresses[trackNumber] = null;
-        },
-        getSmallestProgress: calculateSmallestProgress,
-        updateTrackProgress: (trackNumber, progress) => {
-            if (trackNumberProgresses[trackNumber] === undefined) {
-                throw new Error(`Tried to update progress for a track that was not registered: ${trackNumber}`);
-            }
-            trackNumberProgresses[trackNumber] = progress;
-            eventEmitter.dispatchEvent('progress', {
-                smallestProgress: calculateSmallestProgress(),
-            });
-        },
-        waitForProgress: () => {
-            const { promise, resolve } = (0, with_resolvers_1.withResolvers)();
-            const on = () => {
-                eventEmitter.removeEventListener('progress', on);
-                resolve();
-            };
-            eventEmitter.addEventListener('progress', on);
-            return promise;
-        },
-        getStartingTimestamp,
-        setPossibleLowestTimestamp,
-    };
-};
-exports.makeProgressTracker = makeProgressTracker;

package/dist/create/timescale.d.ts

@@ -1 +0,0 @@
-export declare const CREATE_WEBM_TIME_SCALE = 1000000;

package/dist/create/timescale.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CREATE_WEBM_TIME_SCALE = void 0;
-exports.CREATE_WEBM_TIME_SCALE = 1000000;

package/dist/create/wav/create-wav.d.ts

@@ -1,2 +0,0 @@
-import type { MediaFn, MediaFnGeneratorInput } from '../media-fn';
-export declare const createWav: ({ filename, logLevel, onBytesProgress, onMillisecondsProgress, writer, progressTracker, }: MediaFnGeneratorInput) => Promise<MediaFn>;

package/dist/create/wav/create-wav.js

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWav = void 0;
-const log_1 = require("../../log");
-const numberTo32BiIntLittleEndian = (num) => {
-    return new Uint8Array([
-        num & 0xff,
-        (num >> 8) & 0xff,
-        (num >> 16) & 0xff,
-        (num >> 24) & 0xff,
-    ]);
-};
-const numberTo16BitLittleEndian = (num) => {
-    return new Uint8Array([num & 0xff, (num >> 8) & 0xff]);
-};
-const BIT_DEPTH = 16;
-const BYTES_PER_SAMPLE = BIT_DEPTH / 8;
-const createWav = async ({ filename, logLevel, onBytesProgress, onMillisecondsProgress, writer, progressTracker, }) => {
-    const w = await writer.createContent({ filename, mimeType: 'audio/wav' });
-    await w.write(new Uint8Array([0x52, 0x49, 0x46, 0x46])); // "RIFF"
-    const sizePosition = w.getWrittenByteCount();
-    await w.write(new Uint8Array([0x00, 0x00, 0x00, 0x00])); // Remaining size
-    await w.write(new Uint8Array([0x57, 0x41, 0x56, 0x45])); // "WAVE"
-    await w.write(new Uint8Array([0x66, 0x6d, 0x74, 0x20])); // "fmt "
-    await w.write(new Uint8Array([0x10, 0x00, 0x00, 0x00])); // fmt chunk size = 16
-    await w.write(new Uint8Array([0x01, 0x00])); // Audio format (PCM) = 1, set 3 if float32 would be true
-    const channelNumPosition = w.getWrittenByteCount();
-    await w.write(new Uint8Array([0x01, 0x00])); // Number of channels = 1
-    const sampleRatePosition = w.getWrittenByteCount();
-    await w.write(new Uint8Array([0x0, 0x0, 0x00, 0x00])); // Sample rate
-    const byteRatePosition = w.getWrittenByteCount();
-    await w.write(new Uint8Array([0x0, 0x0, 0x00, 0x00])); // Byte rate
-    const blockAlignPosition = w.getWrittenByteCount();
-    await w.write(new Uint8Array([0x00, 0x00])); // Block align
-    await w.write(numberTo16BitLittleEndian(BIT_DEPTH)); // Bits per sample
-    await w.write(new Uint8Array([0x64, 0x61, 0x74, 0x61])); // "data"
-    const dataSizePosition = w.getWrittenByteCount();
-    await w.write(new Uint8Array([0x00, 0x00, 0x00, 0x00])); // Remaining size
-    const operationProm = { current: Promise.resolve() };
-    const updateSize = async () => {
-        const size = w.getWrittenByteCount() - sizePosition - 4;
-        await w.updateDataAt(sizePosition, numberTo32BiIntLittleEndian(size));
-        const dataSize = w.getWrittenByteCount() - dataSizePosition - 4;
-        await w.updateDataAt(dataSizePosition, numberTo32BiIntLittleEndian(dataSize));
-    };
-    const updateChannelNum = async (numberOfChannels) => {
-        await w.updateDataAt(channelNumPosition, new Uint8Array([numberOfChannels, 0x00]));
-    };
-    const updateSampleRate = async (sampleRate) => {
-        await w.updateDataAt(sampleRatePosition, numberTo32BiIntLittleEndian(sampleRate));
-    };
-    const updateByteRate = async ({ sampleRate, numberOfChannels, }) => {
-        await w.updateDataAt(byteRatePosition, numberTo32BiIntLittleEndian(sampleRate * numberOfChannels + BYTES_PER_SAMPLE));
-    };
-    const updateBlockAlign = async (numberOfChannels) => {
-        await w.updateDataAt(blockAlignPosition, new Uint8Array(numberTo16BitLittleEndian(numberOfChannels * BYTES_PER_SAMPLE)));
-    };
-    const addSample = async (chunk) => {
-        var _a;
-        log_1.Log.verbose(logLevel, 'Adding sample', chunk);
-        await w.write(chunk.data);
-        onMillisecondsProgress((chunk.timestamp + ((_a = chunk.duration) !== null && _a !== void 0 ? _a : 0)) / 1000);
-        onBytesProgress(w.getWrittenByteCount());
-    };
-    const waitForFinishPromises = [];
-    return {
-        save: () => {
-            return w.save();
-        },
-        remove: () => {
-            return w.remove();
-        },
-        addSample: ({ chunk, trackNumber }) => {
-            if (trackNumber !== 1) {
-                throw new Error('Only one track supported for WAV');
-            }
-            operationProm.current = operationProm.current.then(() => addSample(chunk));
-            progressTracker.updateTrackProgress(trackNumber, chunk.timestamp);
-            return operationProm.current;
-        },
-        updateTrackSampleRate: () => {
-            throw new Error('updateTrackSampleRate() not implemented for WAV encoder');
-        },
-        addWaitForFinishPromise: (promise) => {
-            waitForFinishPromises.push(promise);
-        },
-        async waitForFinish() {
-            log_1.Log.verbose(logLevel, 'All write operations queued. Waiting for finish...');
-            await Promise.all(waitForFinishPromises.map((p) => p()));
-            await operationProm.current;
-            await updateSize();
-            await w.waitForFinish();
-        },
-        addTrack: async (track) => {
-            if (track.type !== 'audio') {
-                throw new Error('Only audio tracks supported for WAV');
-            }
-            await updateChannelNum(track.numberOfChannels);
-            await updateSampleRate(track.sampleRate);
-            await updateByteRate({
-                sampleRate: track.sampleRate,
-                numberOfChannels: track.numberOfChannels,
-            });
-            await updateBlockAlign(track.numberOfChannels);
-            progressTracker.registerTrack(1);
-            return Promise.resolve({ trackNumber: 1 });
-        },
-    };
-};
-exports.createWav = createWav;

package/dist/create/with-resolvers.d.ts

@@ -1,10 +0,0 @@
-export declare const withResolvers: <T>() => {
-    promise: Promise<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: any) => void;
-};
-export declare const withResolversAndWaitForReturn: <T>() => {
-    getPromiseToImmediatelyReturn: () => Promise<T>;
-    reject: (reason: unknown) => void;
-    resolve: (value: T | PromiseLike<T>) => void;
-};

package/dist/create/with-resolvers.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withResolversAndWaitForReturn = exports.withResolvers = void 0;
-const withResolvers = function () {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-    });
-    return { promise, resolve: resolve, reject: reject };
-};
-exports.withResolvers = withResolvers;
-const withResolversAndWaitForReturn = () => {
-    const { promise, reject, resolve } = (0, exports.withResolvers)();
-    const { promise: returnPromise, resolve: resolveReturn } = (0, exports.withResolvers)();
-    return {
-        getPromiseToImmediatelyReturn: () => {
-            resolveReturn(undefined);
-            return promise;
-        },
-        reject: (reason) => {
-            returnPromise.then(() => reject(reason));
-        },
-        resolve,
-    };
-};
-exports.withResolversAndWaitForReturn = withResolversAndWaitForReturn;

package/dist/errors/detect-file-type.d.ts

@@ -1 +0,0 @@
-export declare const detectFileType: (data: Uint8Array) => "webp" | "riff" | "webm" | "iso-base-media" | "transport-stream" | "mp3" | "gif" | "png" | "bmp" | "jpeg" | "unknown";

package/dist/errors/detect-file-type.js

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectFileType = void 0;
-const make_header_1 = require("../boxes/webm/make-header");
-const matchesPattern = (pattern) => {
-    return (data) => {
-        return pattern.every((value, index) => data[index] === value);
-    };
-};
-const isRiff = (data) => {
-    const riffPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
-    return matchesPattern(riffPattern)(data.subarray(0, 4));
-};
-const isWebm = (data) => {
-    return matchesPattern(make_header_1.webmPattern)(data.subarray(0, 4));
-};
-const isIsoBaseMedia = (data) => {
-    const isoBaseMediaMp4Pattern = new TextEncoder().encode('ftyp');
-    return matchesPattern(isoBaseMediaMp4Pattern)(data.subarray(4, 8));
-};
-const isTransportStream = (data) => {
-    return data[0] === 0x47 && data[188] === 0x47;
-};
-const isMp3 = (data) => {
-    const mpegPattern = new Uint8Array([0xff, 0xf3, 0xe4, 0x64]);
-    return matchesPattern(mpegPattern)(data.subarray(0, 4));
-};
-const isGif = (data) => {
-    const gifPattern = new Uint8Array([0x47, 0x49, 0x46, 0x38]);
-    return matchesPattern(gifPattern)(data.subarray(0, 4));
-};
-const isPng = (data) => {
-    const pngPattern = new Uint8Array([0x89, 0x50, 0x4e, 0x47]);
-    return matchesPattern(pngPattern)(data.subarray(0, 4));
-};
-const isBmp = (data) => {
-    const bmpPattern = new Uint8Array([0x42, 0x4d]);
-    return matchesPattern(bmpPattern)(data.subarray(0, 2));
-};
-const isJpeg = (data) => {
-    const jpegPattern = new Uint8Array([0xff, 0xd8]);
-    const jpeg = matchesPattern(jpegPattern)(data.subarray(0, 2));
-    if (!jpeg) {
-        return false;
-    }
-    const width = data[6] * 256 + data[7];
-    const height = data[8] * 256 + data[9];
-    console.log(width, height);
-    return true;
-};
-const isWebp = (data) => {
-    const webpPattern = new Uint8Array([0x52, 0x49, 0x46, 0x46]);
-    return matchesPattern(webpPattern)(data.subarray(0, 4));
-};
-const detectFileType = (data) => {
-    if (isWebp(data)) {
-        return 'webp';
-    }
-    if (isRiff(data)) {
-        return 'riff';
-    }
-    if (isWebm(data)) {
-        return 'webm';
-    }
-    if (isIsoBaseMedia(data)) {
-        return 'iso-base-media';
-    }
-    if (isTransportStream(data)) {
-        return 'transport-stream';
-    }
-    if (isMp3(data)) {
-        return 'mp3';
-    }
-    if (isGif(data)) {
-        return 'gif';
-    }
-    if (isPng(data)) {
-        return 'png';
-    }
-    if (isBmp(data)) {
-        return 'bmp';
-    }
-    if (isJpeg(data)) {
-        return 'jpeg';
-    }
-    return 'unknown';
-};
-exports.detectFileType = detectFileType;

package/dist/errors/file-types.d.ts

@@ -1 +0,0 @@
-export declare const detectFileType: (data: Uint8Array) => "mp3" | "unknown" | "webm" | "transport-stream" | "iso-base-media" | "riff" | "gif" | "bmp" | "jpeg" | "png" | "webp";