@remotion/renderer 3.0.30 → 3.0.31

package/dist/stitch-frames-to-gif.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stitchFramesToGif = exports.spawnFfmpeg = void 0;
+const execa_1 = __importDefault(require("execa"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const remotion_1 = require("remotion");
+const get_codec_name_1 = require("./get-codec-name");
+const get_prores_profile_name_1 = require("./get-prores-profile-name");
+const parse_ffmpeg_progress_1 = require("./parse-ffmpeg-progress");
+const validate_even_dimensions_with_codec_1 = require("./validate-even-dimensions-with-codec");
+const validate_ffmpeg_1 = require("./validate-ffmpeg");
+const packageJsonPath = path_1.default.join(__dirname, '..', 'package.json');
+const packageJson = fs_1.default.existsSync(packageJsonPath)
+    ? JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf-8'))
+    : null;
+const spawnFfmpeg = async (options) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    remotion_1.Internals.validateDimension(options.height, 'height', 'passed to `stitchFramesToVideo()`');
+    remotion_1.Internals.validateDimension(options.width, 'width', 'passed to `stitchFramesToVideo()`');
+    remotion_1.Internals.validateFps(options.fps, 'passed to `stitchFramesToVideo()`');
+    const codec = (_a = options.codec) !== null && _a !== void 0 ? _a : remotion_1.Internals.DEFAULT_CODEC;
+    (0, validate_even_dimensions_with_codec_1.validateEvenDimensionsWithCodec)({
+        width: options.width,
+        height: options.height,
+        codec,
+        scale: 1,
+    });
+    const crf = (_b = options.crf) !== null && _b !== void 0 ? _b : remotion_1.Internals.getDefaultCrfForCodec(codec);
+    const pixelFormat = (_c = options.pixelFormat) !== null && _c !== void 0 ? _c : remotion_1.Internals.DEFAULT_PIXEL_FORMAT;
+    await (0, validate_ffmpeg_1.validateFfmpeg)((_d = options.ffmpegExecutable) !== null && _d !== void 0 ? _d : null);
+    const encoderName = (0, get_codec_name_1.getCodecName)(codec);
+    const proResProfileName = (0, get_prores_profile_name_1.getProResProfileName)(codec, options.proResProfile);
+    const supportsCrf = encoderName && codec !== 'prores';
+    if (options.verbose) {
+        console.log('[verbose] ffmpeg', (_e = options.ffmpegExecutable) !== null && _e !== void 0 ? _e : 'ffmpeg in PATH');
+        console.log('[verbose] encoder', encoderName);
+        console.log('[verbose] pixelFormat', pixelFormat);
+        if (supportsCrf) {
+            console.log('[verbose] crf', crf);
+        }
+        console.log('[verbose] codec', codec);
+        console.log('[verbose] proResProfileName', proResProfileName);
+    }
+    remotion_1.Internals.validateSelectedCrfAndCodecCombination(crf, codec);
+    remotion_1.Internals.validateSelectedPixelFormatAndCodecCombination(pixelFormat, codec);
+    const expectedFrames = options.assetsInfo.assets.length;
+    const updateProgress = (preStitchProgress, muxProgress) => {
+        var _a;
+        const totalFrameProgress = 0.5 * preStitchProgress * expectedFrames + muxProgress * 0.5;
+        (_a = options.onProgress) === null || _a === void 0 ? void 0 : _a.call(options, Math.round(totalFrameProgress));
+    };
+    const ffmpegArgs = [
+        ['-r', String(options.fps)],
+        ...(((_f = options.internalOptions) === null || _f === void 0 ? void 0 : _f.preEncodedFileLocation)
+            ? [['-i', (_g = options.internalOptions) === null || _g === void 0 ? void 0 : _g.preEncodedFileLocation]]
+            : [
+                ['-f', 'image2'],
+                ['-s', `${options.width}x${options.height}`],
+                ['-start_number', String(options.assetsInfo.firstFrameIndex)],
+                ['-i', options.assetsInfo.imageSequenceName],
+            ]),
+        // -c:v is the same as -vcodec as -codec:video
+        // and specified the video codec.
+        options.loop === null
+            ? null
+            : ['-loop', typeof options.loop === 'number' ? options.loop : '-1'],
+        // Ignore metadata that may come from remote media
+        ['-map_metadata', '-1'],
+        [
+            '-metadata',
+            `comment=` +
+                [`Made with Remotion`, packageJson ? packageJson.version : null].join(' '),
+        ],
+        options.force ? '-y' : null,
+        options.outputLocation,
+    ];
+    if (options.verbose) {
+        console.log('Generated FFMPEG command:');
+        console.log(ffmpegArgs);
+    }
+    const ffmpegString = ffmpegArgs.flat(2).filter(Boolean);
+    const task = (0, execa_1.default)((_h = options.ffmpegExecutable) !== null && _h !== void 0 ? _h : 'ffmpeg', ffmpegString, {
+        cwd: options.dir,
+    });
+    (_j = options.cancelSignal) === null || _j === void 0 ? void 0 : _j.call(options, () => {
+        task.kill();
+    });
+    let ffmpegOutput = '';
+    let isFinished = false;
+    (_k = task.stderr) === null || _k === void 0 ? void 0 : _k.on('data', (data) => {
+        var _a;
+        const str = data.toString();
+        ffmpegOutput += str;
+        if (options.onProgress) {
+            const parsed = (0, parse_ffmpeg_progress_1.parseFfmpegProgress)(str);
+            // FFMPEG bug: In some cases, FFMPEG does hang after it is finished with it's job
+            // Example repo: https://github.com/JonnyBurger/ffmpeg-repro (access can be given upon request)
+            if (parsed !== undefined) {
+                // If two times in a row the finishing frame is logged, we quit the render
+                if (parsed === expectedFrames) {
+                    if (isFinished) {
+                        (_a = task.stdin) === null || _a === void 0 ? void 0 : _a.write('q');
+                    }
+                    else {
+                        isFinished = true;
+                    }
+                }
+                updateProgress(1, parsed);
+            }
+        }
+    });
+    return { task, getLogs: () => ffmpegOutput };
+};
+exports.spawnFfmpeg = spawnFfmpeg;
+const stitchFramesToGif = async (options) => {
+    const { task, getLogs } = await (0, exports.spawnFfmpeg)(options);
+    try {
+        await task;
+    }
+    catch (err) {
+        throw new Error(getLogs());
+    }
+};
+exports.stitchFramesToGif = stitchFramesToGif;

package/dist/validate-offthreadvideo-image-format.d.ts

@@ -0,0 +1 @@
+export declare const validateOffthreadVideoImageFormat: (input: unknown) => void;

package/dist/validate-offthreadvideo-image-format.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOffthreadVideoImageFormat = void 0;
+const validateOffthreadVideoImageFormat = (input) => {
+    if (typeof input === 'undefined') {
+        return;
+    }
+    if (typeof input !== 'string') {
+        throw new TypeError(`<OffthreadVideo imageFormat=""> must be a string, but got ${JSON.stringify(input)} instead.`);
+    }
+    if (input !== 'png' && input !== 'jpeg') {
+        throw new TypeError(`<OffthreadVideo imageFormat=""> must be either "png" or "jpeg", but got ${input}`);
+    }
+};
+exports.validateOffthreadVideoImageFormat = validateOffthreadVideoImageFormat;

package/dist/ws/buffer-util.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+/**
+ * Merges an array of buffers into a new buffer.
+ *
+ * @param {Buffer[]} list The array of buffers to concat
+ * @param {Number} totalLength The total length of buffers in the list
+ * @return {Buffer} The resulting buffer
+ * @public
+ */
+export declare function concat(list: Buffer[], totalLength: number): Buffer;

package/dist/ws/buffer-util.js

@@ -0,0 +1,123 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concat = void 0;
+const constants_1 = require("./constants");
+/**
+ * Merges an array of buffers into a new buffer.
+ *
+ * @param {Buffer[]} list The array of buffers to concat
+ * @param {Number} totalLength The total length of buffers in the list
+ * @return {Buffer} The resulting buffer
+ * @public
+ */
+function concat(list, totalLength) {
+    if (list.length === 0)
+        return constants_1.constants.EMPTY_BUFFER;
+    if (list.length === 1)
+        return list[0];
+    const target = Buffer.allocUnsafe(totalLength);
+    let offset = 0;
+    for (let i = 0; i < list.length; i++) {
+        const buf = list[i];
+        target.set(buf, offset);
+        offset += buf.length;
+    }
+    if (offset < totalLength)
+        return target.slice(0, offset);
+    return target;
+}
+exports.concat = concat;
+/**
+ * Masks a buffer using the given mask.
+ *
+ * @param {Buffer} source The buffer to mask
+ * @param {Buffer} mask The mask to use
+ * @param {Buffer} output The buffer where to store the result
+ * @param {Number} offset The offset at which to start writing
+ * @param {Number} length The number of bytes to mask.
+ * @public
+ */
+function _mask(source, mask, output, offset, length) {
+    for (let i = 0; i < length; i++) {
+        // eslint-disable-next-line no-bitwise
+        output[offset + i] = source[i] ^ mask[i & 3];
+    }
+}
+/**
+ * Unmasks a buffer using the given mask.
+ *
+ * @param {Buffer} buffer The buffer to unmask
+ * @param {Buffer} mask The mask to use
+ * @public
+ */
+function _unmask(buffer, mask) {
+    for (let i = 0; i < buffer.length; i++) {
+        // eslint-disable-next-line no-bitwise
+        buffer[i] ^= mask[i & 3];
+    }
+}
+/**
+ * Converts a buffer to an `ArrayBuffer`.
+ *
+ * @param {Buffer} buf The buffer to convert
+ * @return {ArrayBuffer} Converted buffer
+ * @public
+ */
+function toArrayBuffer(buf) {
+    if (buf.byteLength === buf.buffer.byteLength) {
+        return buf.buffer;
+    }
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+/**
+ * Converts `data` to a `Buffer`.
+ *
+ * @param {*} data The data to convert
+ * @return {Buffer} The buffer
+ * @throws {TypeError}
+ * @public
+ */
+function toBuffer(data) {
+    toBuffer.readOnly = true;
+    if (Buffer.isBuffer(data))
+        return data;
+    let buf;
+    if (data instanceof ArrayBuffer) {
+        buf = Buffer.from(data);
+    }
+    else if (ArrayBuffer.isView(data)) {
+        buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+    }
+    else {
+        buf = Buffer.from(data);
+        toBuffer.readOnly = false;
+    }
+    return buf;
+}
+module.exports = {
+    mask: _mask,
+    toArrayBuffer,
+    toBuffer,
+    unmask: _unmask,
+};
+/* istanbul ignore else  */
+if (!process.env.WS_NO_BUFFER_UTIL) {
+    try {
+        const bufferUtil = require('bufferutil');
+        module.exports.mask = function (source, mask, output, offset, length) {
+            if (length < 48)
+                _mask(source, mask, output, offset, length);
+            else
+                bufferUtil.mask(source, mask, output, offset, length);
+        };
+        module.exports.unmask = function (buffer, mask) {
+            if (buffer.length < 32)
+                _unmask(buffer, mask);
+            else
+                bufferUtil.unmask(buffer, mask);
+        };
+    }
+    catch (e) {
+        // Continue regardless of the error.
+    }
+}

package/dist/ws/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const constants: {
+    BINARY_TYPES: string[];
+    EMPTY_BUFFER: Buffer;
+    GUID: string;
+    kForOnEventAttribute: symbol;
+    kListener: symbol;
+    kStatusCode: symbol;
+    kWebSocket: symbol;
+    NOOP: () => undefined;
+};

package/dist/ws/constants.js

@@ -0,0 +1,13 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constants = void 0;
+exports.constants = {
+    BINARY_TYPES: ['nodebuffer', 'arraybuffer', 'fragments'],
+    EMPTY_BUFFER: Buffer.alloc(0),
+    GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
+    kForOnEventAttribute: Symbol('kIsForOnEventAttribute'),
+    kListener: Symbol('kListener'),
+    kStatusCode: Symbol('status-code'),
+    kWebSocket: Symbol('websocket'),
+    NOOP: () => undefined,
+};

package/dist/ws/event-target.d.ts

@@ -0,0 +1,155 @@
+declare const kCode: unique symbol;
+declare const kData: unique symbol;
+declare const kError: unique symbol;
+declare const kMessage: unique symbol;
+declare const kReason: unique symbol;
+declare const kTarget: unique symbol;
+declare const kType: unique symbol;
+declare const kWasClean: unique symbol;
+/**
+ * Class representing an event.
+ */
+export declare class Event {
+    /**
+     * Create a new `Event`.
+     *
+     * @param {String} type The name of the event
+     * @throws {TypeError} If the `type` argument is not specified
+     */
+    [kTarget]: null;
+    [kType]: string;
+    constructor(type: string);
+    /**
+     * @type {*}
+     */
+    get target(): null;
+    /**
+     * @type {String}
+     */
+    get type(): string;
+}
+/**
+ * Class representing a close event.
+ *
+ * @extends Event
+ */
+export declare class CloseEvent extends Event {
+    /**
+     * Create a new `CloseEvent`.
+     *
+     * @param {String} type The name of the event
+     * @param {Object} [options] A dictionary object that allows for setting
+     *     attributes via object members of the same name
+     * @param {Number} [options.code=0] The status code explaining why the
+     *     connection was closed
+     * @param {String} [options.reason=''] A human-readable string explaining why
+     *     the connection was closed
+     * @param {Boolean} [options.wasClean=false] Indicates whether or not the
+     *     connection was cleanly closed
+     */
+    [kCode]: number;
+    [kReason]: string;
+    [kWasClean]: boolean;
+    constructor(type: string, options?: {
+        code?: number;
+        reason?: string;
+        wasClean?: boolean;
+    });
+    /**
+     * @type {Number}
+     */
+    get code(): number;
+    /**
+     * @type {String}
+     */
+    get reason(): string;
+    /**
+     * @type {Boolean}
+     */
+    get wasClean(): boolean;
+}
+/**
+ * Class representing an error event.
+ *
+ * @extends Event
+ */
+export declare class ErrorEvent extends Event {
+    /**
+     * Create a new `ErrorEvent`.
+     *
+     * @param {String} type The name of the event
+     * @param {Object} [options] A dictionary object that allows for setting
+     *     attributes via object members of the same name
+     * @param {*} [options.error=null] The error that generated this event
+     * @param {String} [options.message=''] The error message
+     */
+    [kError]: Error | null;
+    [kMessage]: string;
+    constructor(type: string, options?: {
+        error?: Error;
+        message?: string;
+    });
+    /**
+     * @type {*}
+     */
+    get error(): Error | null;
+    /**
+     * @type {String}
+     */
+    get message(): string;
+}
+/**
+ * Class representing a message event.
+ *
+ * @extends Event
+ */
+export declare class MessageEvent extends Event {
+    /**
+     * Create a new `MessageEvent`.
+     *
+     * @param {String} type The name of the event
+     * @param {Object} [options] A dictionary object that allows for setting
+     *     attributes via object members of the same name
+     * @param {*} [options.data=null] The message content
+     */
+    [kData]: unknown;
+    constructor(type: string, options?: {
+        data?: unknown;
+    });
+    /**
+     * @type {*}
+     */
+    get data(): unknown;
+}
+/**
+ * This provides methods for emulating the `EventTarget` interface. It's not
+ * meant to be used directly.
+ *
+ * @mixin
+ */
+export declare const EventTarget: {
+    /**
+     * Register an event listener.
+     *
+     * @param {String} type A string representing the event type to listen for
+     * @param {Function} listener The listener to add
+     * @param {Object} [options] An options object specifies characteristics about
+     *     the event listener
+     * @param {Boolean} [options.once=false] A `Boolean` indicating that the
+     *     listener should be invoked at most once after being added. If `true`,
+     *     the listener would be automatically removed when invoked.
+     * @public
+     */
+    addEventListener(type: 'message' | 'close' | 'error' | 'open', listener: (event: MessageEvent | CloseEvent | ErrorEvent | Event) => void, options?: {
+        once?: boolean;
+    }): void;
+    /**
+     * Remove an event listener.
+     *
+     * @param {String} type A string representing the event type to remove
+     * @param {Function} handler The listener to remove
+     * @public
+     */
+    removeEventListener(type: string, handler: () => undefined): void;
+};
+export {};

package/dist/ws/event-target.js

@@ -0,0 +1,203 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventTarget = exports.MessageEvent = exports.ErrorEvent = exports.CloseEvent = exports.Event = void 0;
+const { kForOnEventAttribute, kListener } = require('./constants');
+const kCode = Symbol('kCode');
+const kData = Symbol('kData');
+const kError = Symbol('kError');
+const kMessage = Symbol('kMessage');
+const kReason = Symbol('kReason');
+const kTarget = Symbol('kTarget');
+const kType = Symbol('kType');
+const kWasClean = Symbol('kWasClean');
+/**
+ * Class representing an event.
+ */
+class Event {
+    constructor(type) {
+        this[kTarget] = null;
+        this[kType] = type;
+    }
+    /**
+     * @type {*}
+     */
+    get target() {
+        return this[kTarget];
+    }
+    /**
+     * @type {String}
+     */
+    get type() {
+        return this[kType];
+    }
+}
+exports.Event = Event;
+Object.defineProperty(Event.prototype, 'target', { enumerable: true });
+Object.defineProperty(Event.prototype, 'type', { enumerable: true });
+/**
+ * Class representing a close event.
+ *
+ * @extends Event
+ */
+class CloseEvent extends Event {
+    constructor(type, options = {}) {
+        super(type);
+        this[kCode] = options.code === undefined ? 0 : options.code;
+        this[kReason] = options.reason === undefined ? '' : options.reason;
+        this[kWasClean] = options.wasClean === undefined ? false : options.wasClean;
+    }
+    /**
+     * @type {Number}
+     */
+    get code() {
+        return this[kCode];
+    }
+    /**
+     * @type {String}
+     */
+    get reason() {
+        return this[kReason];
+    }
+    /**
+     * @type {Boolean}
+     */
+    get wasClean() {
+        return this[kWasClean];
+    }
+}
+exports.CloseEvent = CloseEvent;
+Object.defineProperty(CloseEvent.prototype, 'code', { enumerable: true });
+Object.defineProperty(CloseEvent.prototype, 'reason', { enumerable: true });
+Object.defineProperty(CloseEvent.prototype, 'wasClean', { enumerable: true });
+/**
+ * Class representing an error event.
+ *
+ * @extends Event
+ */
+class ErrorEvent extends Event {
+    constructor(type, options = {}) {
+        super(type);
+        this[kError] = options.error === undefined ? null : options.error;
+        this[kMessage] = options.message === undefined ? '' : options.message;
+    }
+    /**
+     * @type {*}
+     */
+    get error() {
+        return this[kError];
+    }
+    /**
+     * @type {String}
+     */
+    get message() {
+        return this[kMessage];
+    }
+}
+exports.ErrorEvent = ErrorEvent;
+Object.defineProperty(ErrorEvent.prototype, 'error', { enumerable: true });
+Object.defineProperty(ErrorEvent.prototype, 'message', { enumerable: true });
+/**
+ * Class representing a message event.
+ *
+ * @extends Event
+ */
+class MessageEvent extends Event {
+    constructor(type, options = {}) {
+        super(type);
+        this[kData] = options.data === undefined ? null : options.data;
+    }
+    /**
+     * @type {*}
+     */
+    get data() {
+        return this[kData];
+    }
+}
+exports.MessageEvent = MessageEvent;
+Object.defineProperty(MessageEvent.prototype, 'data', { enumerable: true });
+/**
+ * This provides methods for emulating the `EventTarget` interface. It's not
+ * meant to be used directly.
+ *
+ * @mixin
+ */
+exports.EventTarget = {
+    /**
+     * Register an event listener.
+     *
+     * @param {String} type A string representing the event type to listen for
+     * @param {Function} listener The listener to add
+     * @param {Object} [options] An options object specifies characteristics about
+     *     the event listener
+     * @param {Boolean} [options.once=false] A `Boolean` indicating that the
+     *     listener should be invoked at most once after being added. If `true`,
+     *     the listener would be automatically removed when invoked.
+     * @public
+     */
+    addEventListener(type, listener, options = {}) {
+        let wrapper;
+        if (type === 'message') {
+            wrapper = function (data, isBinary) {
+                const event = new MessageEvent('message', {
+                    data: isBinary ? data : data.toString(),
+                });
+                event[kTarget] = this;
+                listener.call(this, event);
+            };
+        }
+        else if (type === 'close') {
+            wrapper = function (code, message) {
+                const event = new CloseEvent('close', {
+                    code,
+                    reason: message.toString(),
+                    wasClean: this._closeFrameReceived && this._closeFrameSent,
+                });
+                event[kTarget] = this;
+                listener.call(this, event);
+            };
+        }
+        else if (type === 'error') {
+            wrapper = function (error) {
+                const event = new ErrorEvent('error', {
+                    error,
+                    message: error.message,
+                });
+                event[kTarget] = this;
+                listener.call(this, event);
+            };
+        }
+        else if (type === 'open') {
+            wrapper = function () {
+                const event = new Event('open');
+                event[kTarget] = this;
+                listener.call(this, event);
+            };
+        }
+        else {
+            return;
+        }
+        wrapper[kForOnEventAttribute] = Boolean(options[kForOnEventAttribute]);
+        wrapper[kListener] = listener;
+        if (options.once) {
+            this.once(type, wrapper);
+        }
+        else {
+            this.on(type, wrapper);
+        }
+    },
+    /**
+     * Remove an event listener.
+     *
+     * @param {String} type A string representing the event type to remove
+     * @param {Function} handler The listener to remove
+     * @public
+     */
+    removeEventListener(type, handler) {
+        for (const listener of this.listeners(type)) {
+            if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
+                this.removeListener(type, listener);
+                break;
+            }
+        }
+    },
+};

package/dist/ws/extension.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Parses the `Sec-WebSocket-Extensions` header into an object.
+ *
+ * @param {String} header The field value of the header
+ * @return {Object} The parsed object
+ * @public
+ */
+export declare function parse(header: string): any;
+/**
+ * Builds the `Sec-WebSocket-Extensions` header field value.
+ *
+ * @param {Object} extensions The map of extensions and parameters to format
+ * @return {String} A string representing the given object
+ * @public
+ */
+export declare function format(extensions: Record<string, Record<string, any>>): string;