@efxlab/motion-canvas-ffmpeg 4.0.0

package/lib/client/FFmpegExporterClient.d.ts

@@ -0,0 +1,44 @@
+import type { Exporter, MetaField, Project, RendererResult, RendererSettings, Sound } from '@efxlab/motion-canvas-core';
+/**
+ * FFmpeg video exporter.
+ *
+ * @remarks
+ * Most of the export logic is handled on the server. This class communicates
+ * with the FFmpegBridge through a WebSocket connection which lets it invoke
+ * methods on the FFmpegExporterServer class.
+ *
+ * For example, calling the following method:
+ * ```ts
+ * async this.invoke('process', 7);
+ * ```
+ * Will invoke the `process` method on the FFmpegExporterServer class with `7`
+ * as the argument. The result of the method will be returned as a Promise.
+ *
+ * Before any methods can be invoked, the FFmpegExporterServer class must be
+ * initialized by invoking `start`.
+ */
+export declare class FFmpegExporterClient implements Exporter {
+    private readonly project;
+    private readonly settings;
+    static readonly id = "@efxlab/motion-canvas-ffmpeg";
+    static readonly displayName = "Video (FFmpeg)";
+    static meta(project: Project): MetaField<any>;
+    static create(project: Project, settings: RendererSettings): Promise<FFmpegExporterClient>;
+    private static readonly response;
+    private concurrentFrames;
+    private error;
+    constructor(project: Project, settings: RendererSettings);
+    start(sounds: Sound[], duration: number): Promise<void>;
+    handleFrame(canvas: HTMLCanvasElement, _frame: number, _sceneFrame: number, _sceneName: string, _signal: AbortSignal, context: CanvasRenderingContext2D): Promise<void>;
+    stop(result: RendererResult): Promise<void>;
+    /**
+     * Remotely invoke a method on the server and wait for a response.
+     *
+     * @param method - The method name to execute on the server.
+     * @param data - The data that will be passed as an argument to the method.
+     *               Should be serializable.
+     * @param strategy - How the data should be sent to the server.
+     */
+    private invoke;
+}
+//# sourceMappingURL=FFmpegExporterClient.d.ts.map

package/lib/client/FFmpegExporterClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FFmpegExporterClient.d.ts","sourceRoot":"","sources":["../../client/FFmpegExporterClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,SAAS,EACT,OAAO,EACP,cAAc,EACd,gBAAgB,EAChB,KAAK,EACN,MAAM,4BAA4B,CAAC;AA8BpC;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,oBAAqB,YAAW,QAAQ;IAiCjD,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAjC3B,gBAAuB,EAAE,kCAAkC;IAC3D,gBAAuB,WAAW,oBAAoB;WAExC,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC,GAAG,CAAC;WAUhC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,gBAAgB;IAIvE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAyC;IAWzE,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,KAAK,CAAkB;gBAGZ,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,gBAAgB;IAGhC,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAavD,WAAW,CACtB,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,IAAI,CAAC;IAqBH,IAAI,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAYxD;;;;;;;OAOG;IACH,OAAO,CAAC,MAAM;CA0Cf"}

package/lib/client/FFmpegExporterClient.js

@@ -0,0 +1,135 @@
+var _a;
+import { BoolMetaField, EventDispatcher, NumberMetaField, ObjectMetaField, } from '@efxlab/motion-canvas-core';
+const EXPORT_FRAME_LIMIT = 256;
+const EXPORT_RETRY_DELAY = 1000;
+/**
+ * FFmpeg video exporter.
+ *
+ * @remarks
+ * Most of the export logic is handled on the server. This class communicates
+ * with the FFmpegBridge through a WebSocket connection which lets it invoke
+ * methods on the FFmpegExporterServer class.
+ *
+ * For example, calling the following method:
+ * ```ts
+ * async this.invoke('process', 7);
+ * ```
+ * Will invoke the `process` method on the FFmpegExporterServer class with `7`
+ * as the argument. The result of the method will be returned as a Promise.
+ *
+ * Before any methods can be invoked, the FFmpegExporterServer class must be
+ * initialized by invoking `start`.
+ */
+export class FFmpegExporterClient {
+    static meta(project) {
+        return new ObjectMetaField(this.displayName, {
+            fastStart: new BoolMetaField('fast start', true),
+            includeAudio: new BoolMetaField('include audio', true).disable(!project.audio),
+            audioSampleRate: new NumberMetaField('audio sample rate', 48000),
+        });
+    }
+    static async create(project, settings) {
+        return new _a(project, settings);
+    }
+    constructor(project, settings) {
+        this.project = project;
+        this.settings = settings;
+        this.concurrentFrames = 0;
+        this.error = false;
+    }
+    async start(sounds, duration) {
+        const options = this.settings.exporter.options;
+        await this.invoke('start', {
+            ...this.settings,
+            ...options,
+            audio: this.project.audio,
+            audioOffset: this.project.meta.shared.audioOffset.get() - this.settings.range[0],
+            sounds,
+            duration,
+        });
+    }
+    async handleFrame(canvas, _frame, _sceneFrame, _sceneName, _signal, context) {
+        while (this.concurrentFrames >= EXPORT_FRAME_LIMIT) {
+            await new Promise(resolve => setTimeout(resolve, EXPORT_RETRY_DELAY));
+        }
+        if (this.error) {
+            throw this.error;
+        }
+        const data = context.getImageData(0, 0, canvas.width, canvas.height).data;
+        this.concurrentFrames++;
+        this.invoke('handleFrame', data, 'octet-stream')
+            .then(() => {
+            this.concurrentFrames--;
+        })
+            .catch(error => {
+            this.error = error;
+            this.concurrentFrames--;
+        });
+    }
+    async stop(result) {
+        while (this.concurrentFrames >= EXPORT_FRAME_LIMIT) {
+            await new Promise(resolve => setTimeout(resolve, EXPORT_RETRY_DELAY));
+        }
+        if (this.error) {
+            throw this.error;
+        }
+        await this.invoke('end', result);
+    }
+    /**
+     * Remotely invoke a method on the server and wait for a response.
+     *
+     * @param method - The method name to execute on the server.
+     * @param data - The data that will be passed as an argument to the method.
+     *               Should be serializable.
+     * @param strategy - How the data should be sent to the server.
+     */
+    invoke(method, data, strategy = 'ws') {
+        if (import.meta.hot) {
+            return new Promise((resolve, reject) => {
+                const handle = (response) => {
+                    if (response.method !== method) {
+                        return;
+                    }
+                    _a.response.unsubscribe(handle);
+                    if (response.status === 'success') {
+                        resolve(response.data);
+                    }
+                    else {
+                        reject({
+                            message: 'An error occurred while exporting the video.',
+                            remarks: `Method: ${method}<br>Server error: ${response.message}`,
+                            object: data,
+                        });
+                    }
+                };
+                _a.response.subscribe(handle);
+                switch (strategy) {
+                    case 'ws':
+                        import.meta.hot.send('motion-canvas/ffmpeg', { method, data });
+                        break;
+                    case 'octet-stream':
+                        fetch(`/ffmpeg/${method}`, {
+                            method: 'POST',
+                            body: data,
+                            // eslint-disable-next-line @typescript-eslint/naming-convention
+                            headers: { 'Content-Type': 'application/octet-stream' },
+                        }).catch(reject);
+                        break;
+                }
+            });
+        }
+        else {
+            throw new Error('FFmpegExporter can only be used locally.');
+        }
+    }
+}
+_a = FFmpegExporterClient;
+FFmpegExporterClient.id = '@efxlab/motion-canvas-ffmpeg';
+FFmpegExporterClient.displayName = 'Video (FFmpeg)';
+FFmpegExporterClient.response = new EventDispatcher();
+(() => {
+    if (import.meta.hot) {
+        import.meta.hot.on(`motion-canvas/ffmpeg-ack`, (response) => _a.response.dispatch(response));
+    }
+})();
+//# sourceMappingURL=data:application/json;base64,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

package/lib/client/index.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => import("@efxlab/motion-canvas-core").Plugin;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../client/index.ts"],"names":[],"mappings":";AAIA,wBAKG"}

package/lib/client/index.js

@@ -0,0 +1,9 @@
+import { makePlugin } from '@efxlab/motion-canvas-core';
+import { FFmpegExporterClient } from './FFmpegExporterClient';
+export default makePlugin({
+    name: 'ffmpeg-plugin',
+    exporters() {
+        return [FFmpegExporterClient];
+    },
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9jbGllbnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFDLFVBQVUsRUFBQyxNQUFNLDRCQUE0QixDQUFDO0FBQ3RELE9BQU8sRUFBQyxvQkFBb0IsRUFBQyxNQUFNLHdCQUF3QixDQUFDO0FBRTVELGVBQWUsVUFBVSxDQUFDO0lBQ3hCLElBQUksRUFBRSxlQUFlO0lBQ3JCLFNBQVM7UUFDUCxPQUFPLENBQUMsb0JBQW9CLENBQUMsQ0FBQztJQUNoQyxDQUFDO0NBQ0YsQ0FBQyxDQUFDIn0=

package/lib/server/FFmpegBridge.d.ts

@@ -0,0 +1,20 @@
+import { PluginConfig } from '@efxlab/motion-canvas-vite-plugin';
+import { ViteDevServer } from 'vite';
+/**
+ * A simple bridge between the FFmpegExporterServer and FFmpegExporterClient.
+ *
+ * @remarks
+ * This class lets the client exporter invoke methods on the server and receive
+ * responses using a simple Promise-based API.
+ */
+export declare class FFmpegBridge {
+    private readonly server;
+    private readonly config;
+    private process;
+    constructor(server: ViteDevServer, config: PluginConfig);
+    private handleRequest;
+    private handleMessage;
+    private respondSuccess;
+    private respondError;
+}
+//# sourceMappingURL=FFmpegBridge.d.ts.map

package/lib/server/FFmpegBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FFmpegBridge.d.ts","sourceRoot":"","sources":["../../server/FFmpegBridge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,mCAAmC,CAAC;AAE/D,OAAO,EAAU,aAAa,EAAC,MAAM,MAAM,CAAC;AAW5C;;;;;;GAMG;AACH,qBAAa,YAAY;IAIrB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAJzB,OAAO,CAAC,OAAO,CAAqC;gBAGjC,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,YAAY;IAMvC,OAAO,CAAC,aAAa,CASnB;IAEF,OAAO,CAAC,aAAa,CAiCnB;IAEF,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,YAAY;CAOrB"}

package/lib/server/FFmpegBridge.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FFmpegBridge = void 0;
+const FFmpegExporterServer_1 = require("./FFmpegExporterServer");
+/**
+ * A simple bridge between the FFmpegExporterServer and FFmpegExporterClient.
+ *
+ * @remarks
+ * This class lets the client exporter invoke methods on the server and receive
+ * responses using a simple Promise-based API.
+ */
+class FFmpegBridge {
+    constructor(server, config) {
+        this.server = server;
+        this.config = config;
+        this.process = null;
+        this.handleRequest = async (req, res) => {
+            res.end();
+            await this.handleMessage({
+                method: req.url.slice(1),
+                data: req,
+            });
+        };
+        this.handleMessage = async ({ method, data }) => {
+            if (method === 'start') {
+                try {
+                    this.process = new FFmpegExporterServer_1.FFmpegExporterServer(data, this.config);
+                    this.respondSuccess(method, await this.process.start());
+                }
+                catch (e) {
+                    this.respondError(method, e?.message);
+                }
+                return;
+            }
+            if (!this.process) {
+                this.respondError(method, 'The exporting process has not been started.');
+                return;
+            }
+            if (!(method in this.process)) {
+                this.respondError(method, `Unknown method: "${method}".`);
+                return;
+            }
+            try {
+                this.respondSuccess(method, await this.process[method](data));
+            }
+            catch (e) {
+                this.respondError(method, e?.message);
+            }
+            if (method === 'end') {
+                this.process = null;
+            }
+        };
+        server.ws.on('motion-canvas/ffmpeg', this.handleMessage);
+        server.middlewares.use('/ffmpeg', this.handleRequest);
+    }
+    respondSuccess(method, data = {}) {
+        this.server.ws.send('motion-canvas/ffmpeg-ack', {
+            status: 'success',
+            method,
+            data,
+        });
+    }
+    respondError(method, message = 'Unknown error.') {
+        this.server.ws.send('motion-canvas/ffmpeg-ack', {
+            status: 'error',
+            method,
+            message,
+        });
+    }
+}
+exports.FFmpegBridge = FFmpegBridge;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/server/FFmpegExporterServer.d.ts

@@ -0,0 +1,26 @@
+import type { RendererResult, RendererSettings, Sound } from '@efxlab/motion-canvas-core';
+import type { PluginConfig } from '@efxlab/motion-canvas-vite-plugin';
+import { Readable } from 'stream';
+export interface FFmpegExporterSettings extends RendererSettings {
+    audio?: string;
+    audioOffset?: number;
+    sounds: Sound[];
+    duration: number;
+    fastStart: boolean;
+    includeAudio: boolean;
+    audioSampleRate: number;
+}
+/**
+ * The server-side implementation of the FFmpeg video exporter.
+ */
+export declare class FFmpegExporterServer {
+    private readonly config;
+    private readonly stream;
+    private readonly command;
+    private readonly promise;
+    constructor(settings: FFmpegExporterSettings, config: PluginConfig);
+    start(): Promise<void>;
+    handleFrame(req: Readable): Promise<void>;
+    end(result: RendererResult): Promise<void>;
+}
+//# sourceMappingURL=FFmpegExporterServer.d.ts.map

package/lib/server/FFmpegExporterServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FFmpegExporterServer.d.ts","sourceRoot":"","sources":["../../server/FFmpegExporterServer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,gBAAgB,EAChB,KAAK,EACN,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,mCAAmC,CAAC;AAMpE,OAAO,EAAC,QAAQ,EAAC,MAAM,QAAQ,CAAC;AAMhC,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IAEjB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB;AAoBD;;GAEG;AACH,qBAAa,oBAAoB;IAO7B,OAAO,CAAC,QAAQ,CAAC,MAAM;IANzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAc;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAC/C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAgB;gBAGtC,QAAQ,EAAE,sBAAsB,EACf,MAAM,EAAE,YAAY;IAgI1B,KAAK;IAQL,WAAW,CAAC,GAAG,EAAE,QAAQ;IAIzB,GAAG,CAAC,MAAM,EAAE,cAAc;CAaxC"}

package/lib/server/FFmpegExporterServer.js

@@ -0,0 +1,208 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FFmpegExporterServer = void 0;
+const ffmpeg_ffprobe_static_1 = require("ffmpeg-ffprobe-static");
+const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ImageStream_1 = require("./ImageStream");
+fluent_ffmpeg_1.default.setFfmpegPath(ffmpeg_ffprobe_static_1.ffmpegPath);
+fluent_ffmpeg_1.default.setFfprobePath(ffmpeg_ffprobe_static_1.ffprobePath);
+function formatFilters(filters) {
+    return filters
+        .map(f => {
+        let options = [];
+        if (typeof f.options === 'string') {
+            options = [f.options];
+        }
+        else if (f.options.constructor === Array) {
+            options = f.options;
+        }
+        else {
+            options = Object.entries(f.options)
+                .filter(([, v]) => v !== undefined)
+                .map(([k, v]) => `${k}=${v}`);
+        }
+        return `${f.filter}=${options.join(':')}`;
+    })
+        .join(',');
+}
+/**
+ * The server-side implementation of the FFmpeg video exporter.
+ */
+class FFmpegExporterServer {
+    constructor(settings, config) {
+        this.config = config;
+        const size = {
+            x: Math.round(settings.size.x * settings.resolutionScale),
+            y: Math.round(settings.size.y * settings.resolutionScale),
+        };
+        this.stream = new ImageStream_1.ImageStream(size);
+        this.command = (0, fluent_ffmpeg_1.default)();
+        // Input image sequence
+        this.command
+            .input(this.stream)
+            .inputFormat('rawvideo')
+            .inputOptions(['-pix_fmt rgba', '-s:v', `${size.x}x${size.y}`])
+            .inputFps(settings.fps);
+        // Input audio
+        const sounds = [...settings.sounds];
+        if (settings.audio && settings.includeAudio) {
+            sounds.push({
+                audio: settings.audio,
+                realPlaybackRate: 1,
+                offset: settings.audioOffset ?? 0,
+            });
+        }
+        const filterSpec = [];
+        const streams = [];
+        for (let i = 0; i < sounds.length; i++) {
+            const sound = sounds[i];
+            this.command.input(sound.audio.slice(1));
+            let trimmed = sound.start ?? 0;
+            if (sound.offset < 0) {
+                trimmed -= sound.offset * sound.realPlaybackRate;
+            }
+            if (trimmed !== 0) {
+                this.command.inputOptions(`-ss ${trimmed}`);
+            }
+            const filters = [];
+            if (sound.end !== undefined) {
+                filters.push({
+                    filter: 'atrim',
+                    options: { end: sound.end - trimmed },
+                });
+            }
+            filters.push({
+                filter: 'aresample',
+                options: settings.audioSampleRate.toString(),
+            });
+            if (sound.gain) {
+                filters.push({
+                    filter: 'volume',
+                    options: { volume: `${sound.gain}dB` },
+                });
+            }
+            if (sound.realPlaybackRate !== 1) {
+                const rate = Math.round(settings.audioSampleRate * sound.realPlaybackRate);
+                filters.push({
+                    filter: 'asetrate',
+                    options: { r: rate },
+                });
+                filters.push({
+                    filter: 'aresample',
+                    options: settings.audioSampleRate.toString(),
+                });
+            }
+            if (sound.offset > 0) {
+                const delay = Math.round(sound.offset * 1000);
+                filters.push({
+                    filter: 'adelay',
+                    options: { delays: delay, all: 1 },
+                });
+            }
+            if (filters.length > 0) {
+                filterSpec.push({
+                    inputs: `${i + 1}:a`,
+                    filter: formatFilters(filters),
+                    outputs: `a${i + 1}`,
+                });
+                streams.push(`a${i + 1}`);
+            }
+            else {
+                streams.push(`${i + 1}:a`);
+            }
+        }
+        if (sounds.length > 0) {
+            this.command.complexFilter([
+                ...filterSpec,
+                {
+                    filter: 'amix',
+                    // eslint-disable-next-line @typescript-eslint/naming-convention
+                    options: { inputs: sounds.length, dropout_transition: 0, normalize: 0 },
+                    inputs: streams,
+                    outputs: 'a',
+                },
+            ]);
+            this.command.outputOptions(['-map 0:v', '-map [a]']);
+        }
+        // Output settings
+        this.command
+            .output(path.join(this.config.output, `${settings.name}.mp4`))
+            .outputOptions([
+            '-pix_fmt yuv420p',
+            `-t ${settings.duration / settings.fps}`,
+        ])
+            .outputFps(settings.fps)
+            .size(`${size.x}x${size.y}`);
+        if (settings.fastStart) {
+            this.command.outputOptions(['-movflags +faststart']);
+        }
+        this.promise = new Promise((resolve, reject) => {
+            this.command.on('end', () => resolve()).on('error', reject);
+        });
+    }
+    async start() {
+        if (!fs.existsSync(this.config.output)) {
+            await fs.promises.mkdir(this.config.output, { recursive: true });
+        }
+        this.command.on('stderr', console.error);
+        this.command.run();
+    }
+    async handleFrame(req) {
+        await this.stream.pushImage(req);
+    }
+    async end(result) {
+        this.stream.pushImage(null);
+        if (result === 1) {
+            try {
+                this.command.kill('SIGKILL');
+                await this.promise;
+            }
+            catch (_) {
+                // do nothing
+            }
+        }
+        else {
+            await this.promise;
+        }
+    }
+}
+exports.FFmpegExporterServer = FFmpegExporterServer;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/server/ImageStream.d.ts

@@ -0,0 +1,12 @@
+import { Readable } from 'stream';
+export declare class ImageStream extends Readable {
+    private size;
+    private queue;
+    constructor(size: {
+        x: number;
+        y: number;
+    });
+    pushImage(readable: Readable | null): Promise<void>;
+    _read(): void;
+}
+//# sourceMappingURL=ImageStream.d.ts.map

package/lib/server/ImageStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImageStream.d.ts","sourceRoot":"","sources":["../../server/ImageStream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAC,MAAM,QAAQ,CAAC;AAYhC,qBAAa,WAAY,SAAQ,QAAQ;IAGpB,OAAO,CAAC,IAAI;IAF/B,OAAO,CAAC,KAAK,CAAmB;gBAEL,IAAI,EAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC;IAI1C,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IA6BhC,KAAK;CAiBtB"}

package/lib/server/ImageStream.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageStream = void 0;
+const stream_1 = require("stream");
+class ImageStream extends stream_1.Readable {
+    constructor(size) {
+        super();
+        this.size = size;
+        this.queue = [];
+    }
+    async pushImage(readable) {
+        if (readable) {
+            const length = this.size.x * this.size.y * 4;
+            const item = {
+                type: 'frame',
+                array: new Uint8Array(length),
+                finished: false,
+            };
+            this.queue.push(item);
+            let pointer = 0;
+            readable.on('data', (chunk) => {
+                item.array.set(chunk, pointer);
+                pointer += chunk.length;
+            });
+            await new Promise((resolve, reject) => {
+                readable.on('end', resolve).on('error', reject);
+            });
+            item.finished = true;
+        }
+        else {
+            this.queue.push({ type: 'end' });
+        }
+        this._read();
+    }
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    _read() {
+        while (this.queue.length > 0) {
+            const item = this.queue[0];
+            if (item.type === 'end') {
+                this.queue = [];
+                this.push(null);
+                return;
+            }
+            if (!item.finished) {
+                return;
+            }
+            this.queue.shift();
+            this.push(item.array);
+        }
+    }
+}
+exports.ImageStream = ImageStream;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/server/index.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from '@efxlab/motion-canvas-vite-plugin';
+declare const _default: () => Plugin;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,MAAM,EAGP,MAAM,mCAAmC,CAAC;8BAGxB,MAAM;AAAzB,wBAcE"}

package/lib/server/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const motion_canvas_vite_plugin_1 = require("@efxlab/motion-canvas-vite-plugin");
+const FFmpegBridge_1 = require("./FFmpegBridge");
+exports.default = () => {
+    let config;
+    return {
+        name: 'motion-canvas/ffmpeg',
+        [motion_canvas_vite_plugin_1.PLUGIN_OPTIONS]: {
+            entryPoint: '@efxlab/motion-canvas-ffmpeg/lib/client',
+            async config(value) {
+                config = value;
+            },
+        },
+        configureServer(server) {
+            new FFmpegBridge_1.FFmpegBridge(server, config);
+        },
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zZXJ2ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxpRkFJMkM7QUFDM0MsaURBQTRDO0FBRTVDLGtCQUFlLEdBQVcsRUFBRTtJQUMxQixJQUFJLE1BQW9CLENBQUM7SUFDekIsT0FBTztRQUNMLElBQUksRUFBRSxzQkFBc0I7UUFDNUIsQ0FBQywwQ0FBYyxDQUFDLEVBQUU7WUFDaEIsVUFBVSxFQUFFLHlDQUF5QztZQUNyRCxLQUFLLENBQUMsTUFBTSxDQUFDLEtBQUs7Z0JBQ2hCLE1BQU0sR0FBRyxLQUFLLENBQUM7WUFDakIsQ0FBQztTQUNGO1FBQ0QsZUFBZSxDQUFDLE1BQVc7WUFDekIsSUFBSSwyQkFBWSxDQUFDLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FBQztRQUNuQyxDQUFDO0tBQ0YsQ0FBQztBQUNKLENBQUMsQ0FBQyJ9

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@efxlab/motion-canvas-ffmpeg",
+  "version": "4.0.0",
+  "description": "An FFmpeg video exporter for Motion Canvas",
+  "main": "lib/server/index.js",
+  "author": "motion-canvas",
+  "homepage": "https://motioncanvas.io/",
+  "bugs": "https://github.com/motion-canvas/motion-canvas/issues",
+  "license": "GPLv3",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "npm run client:build && npm run server:build",
+    "client:build": "tsc --project client/tsconfig.json",
+    "client:dev": "tsc -w --project client/tsconfig.json",
+    "server:build": "tsc --project server/tsconfig.json",
+    "server:dev": "tsc -w --project server/tsconfig.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/electroheadfx/efx-motion-canvas.git"
+  },
+  "files": [
+    "lib"
+  ],
+  "devDependencies": {
+    "@types/fluent-ffmpeg": "^2.1.21"
+  },
+  "dependencies": {
+    "@efxlab/motion-canvas-core": "workspace:*",
+    "@efxlab/motion-canvas-vite-plugin": "workspace:*",
+    "ffmpeg-ffprobe-static": "^6.1.1-rc.5",
+    "fluent-ffmpeg": "^2.1.3"
+  }
+}