@remotion/media-parser 4.0.245 → 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/esm/buffer.mjs

@@ -1,56 +0,0 @@
-// src/writers/buffer-implementation/writer.ts
-var createContent = ({ filename, mimeType }) => {
-  const buf = new ArrayBuffer(0, {
-    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(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);
-};
-
-// src/writers/buffer.ts
-var bufferWriter = {
-  createContent
-};
-export {
-  bufferWriter
-};

package/dist/esm/web-fs.mjs

@@ -1,74 +0,0 @@
-// src/writers/web-fs.ts
-var createContent = async ({ filename }) => {
-  const directoryHandle = await navigator.storage.getDirectory();
-  const actualFilename = `__remotion_mediaparser:${filename}`;
-  const remove = async () => {
-    await directoryHandle.removeEntry(actualFilename, {
-      recursive: true
-    });
-  };
-  await remove();
-  const fileHandle = await directoryHandle.getFileHandle(actualFilename, {
-    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 writer = {
-    write: (arr) => {
-      writPromise = writPromise.then(() => write(arr));
-      return writPromise;
-    },
-    save: async () => {
-      try {
-        await writable.close();
-      } catch {
-      }
-      const newHandle = await directoryHandle.getFileHandle(actualFilename, {
-        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;
-};
-var webFsWriter = {
-  createContent
-};
-var 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;
-};
-export {
-  webFsWriter,
-  canUseWebFsWriter
-};

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

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