@twick/ffmpeg 0.11.0

package/dist/video-frame-extractor.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoFrameExtractor = void 0;
+const telemetry_1 = require("@twick/telemetry");
+const ffmpeg = require("fluent-ffmpeg");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const uuid_1 = require("uuid");
+const settings_1 = require("./settings");
+const utils_1 = require("./utils");
+/**
+ * Walks through a video file and extracts frames.
+ */
+class VideoFrameExtractor {
+    constructor(filePath, startTime, fps, duration) {
+        this.ffmpegPath = settings_1.ffmpegSettings.getFfmpegPath();
+        this.buffer = Buffer.alloc(0);
+        this.bufferOffset = 0;
+        // Images are buffered in memory until they are requested.
+        this.imageBuffers = [];
+        this.lastImage = null;
+        this.framesProcessed = 0;
+        this.width = 0;
+        this.height = 0;
+        this.frameSize = 0;
+        this.codec = null;
+        this.process = null;
+        this.terminated = false;
+        this.state = 'processing';
+        this.filePath = filePath;
+        this.downloadedFilePath = VideoFrameExtractor.downloadedVideoMap.get(filePath)?.localPath;
+        this.startTimeOffset = VideoFrameExtractor.downloadedVideoMap.get(filePath)
+            ?.startTimeOffset;
+        this.startTime = startTime;
+        this.duration = duration;
+        this.toTime = this.getEndTime(this.startTime);
+        this.fps = fps;
+        (0, utils_1.getVideoMetadata)(this.downloadedFilePath).then(metadata => {
+            this.width = metadata.width;
+            this.height = metadata.height;
+            this.frameSize = this.width * this.height * 4;
+            this.buffer = Buffer.alloc(this.frameSize);
+            this.codec = metadata.codec;
+            if (this.startTime >= this.duration) {
+                this.process = this.createFfmpegProcessToExtractFirstFrame(this.downloadedFilePath, this.codec);
+                return;
+            }
+            this.process = this.createFfmpegProcess(this.startTime - this.startTimeOffset, this.toTime, this.downloadedFilePath, this.fps, this.codec);
+        });
+    }
+    static downloadVideoChunk(url, startTime, endTime) {
+        const outputDir = path.join(os.tmpdir(), `twick-decoder-chunks`);
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        return new Promise((resolve, reject) => {
+            ffmpeg.ffprobe(url, (err, metadata) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                const format = metadata.format.format_name?.split(',')[-1] || 'mp4';
+                const outputFileName = `chunk_${(0, uuid_1.v4)()}.${format}`;
+                const outputPath = path.join(outputDir, outputFileName);
+                const toleranceInSeconds = 0.5;
+                const adjustedStartTime = Math.max(startTime - toleranceInSeconds, 0);
+                ffmpeg(url)
+                    .setFfmpegPath(settings_1.ffmpegSettings.getFfmpegPath())
+                    .inputOptions([
+                    `-ss ${adjustedStartTime}`,
+                    `-to ${endTime + toleranceInSeconds}`,
+                ])
+                    .outputOptions(['-c copy'])
+                    .output(outputPath)
+                    .on('end', () => {
+                    this.downloadedVideoMap.set(url, {
+                        localPath: outputPath,
+                        startTimeOffset: adjustedStartTime,
+                    });
+                    resolve(outputPath);
+                })
+                    .on('error', err => reject(err))
+                    .run();
+            });
+        });
+    }
+    getTime() {
+        return this.startTime + this.framesProcessed / this.fps;
+    }
+    getLastTime() {
+        return this.startTime + (this.framesProcessed - 1) / this.fps;
+    }
+    getLastFrame() {
+        return this.lastImage;
+    }
+    getWidth() {
+        return this.width;
+    }
+    getHeight() {
+        return this.height;
+    }
+    getEndTime(startTime) {
+        return Math.min(startTime + VideoFrameExtractor.chunkLengthInSeconds, this.duration);
+    }
+    getArgs(codec, range, fps) {
+        const inputOptions = [];
+        const outputOptions = [];
+        inputOptions.push('-loglevel', settings_1.ffmpegSettings.getLogLevel());
+        if (range) {
+            inputOptions.push(...['-ss', range[0].toFixed(2), '-to', range[1].toFixed(2)]);
+        }
+        if (codec === 'vp9') {
+            inputOptions.push('-vcodec', 'libvpx-vp9');
+        }
+        if (fps) {
+            outputOptions.push('-vf', `fps=fps=${fps}`);
+        }
+        if (!range) {
+            outputOptions.push('-vframes', '1');
+        }
+        outputOptions.push('-f', 'rawvideo');
+        outputOptions.push('-pix_fmt', 'rgba');
+        return { inputOptions, outputOptions };
+    }
+    createFfmpegProcess(startTime, toTime, filePath, fps, codec) {
+        const { inputOptions, outputOptions } = this.getArgs(codec, [startTime, toTime], fps);
+        const process = ffmpeg(filePath)
+            .setFfmpegPath(this.ffmpegPath)
+            .inputOptions(inputOptions)
+            .outputOptions(outputOptions)
+            .on('end', () => {
+            this.handleClose(0);
+        })
+            .on('error', err => {
+            this.handleError(err);
+        })
+            .on('stderr', stderrLine => {
+            console.log(stderrLine);
+        })
+            .on('stdout', stderrLine => {
+            console.log(stderrLine);
+        });
+        const ffstream = process.pipe();
+        ffstream.on('data', (data) => {
+            this.processData(data);
+        });
+        return process;
+    }
+    /**
+     * We call this in the case that the time requested is greater than the
+     * duration of the video. In this case, we want to display the first frame
+     * of the video.
+     *
+     * Note: This does NOT match the behavior of the old implementation
+     * inside of 2d/src/lib/components/Video.ts. In the old implementation, the
+     * last frame is shown instead of the first frame.
+     */
+    createFfmpegProcessToExtractFirstFrame(filePath, codec) {
+        const { inputOptions, outputOptions } = this.getArgs(codec, undefined, undefined);
+        const process = ffmpeg(filePath)
+            .setFfmpegPath(this.ffmpegPath)
+            .inputOptions(inputOptions)
+            .outputOptions(outputOptions)
+            .on('end', () => {
+            this.handleClose(0);
+        })
+            .on('error', err => {
+            this.handleError(err);
+        })
+            .on('stderr', stderrLine => {
+            console.log(stderrLine);
+        })
+            .on('stdout', stderrLine => {
+            console.log(stderrLine);
+        });
+        const ffstream = process.pipe();
+        ffstream.on('data', (data) => {
+            this.processData(data);
+        });
+        return process;
+    }
+    processData(data) {
+        let dataOffset = 0;
+        while (dataOffset < data.length) {
+            const remainingSpace = this.frameSize - this.bufferOffset;
+            const chunkSize = Math.min(remainingSpace, data.length - dataOffset);
+            data.copy(this.buffer, this.bufferOffset, dataOffset, dataOffset + chunkSize);
+            this.bufferOffset += chunkSize;
+            dataOffset += chunkSize;
+            // We have a complete frame
+            if (this.bufferOffset === this.frameSize) {
+                this.imageBuffers.push(Buffer.from(this.buffer)); // Create a copy
+                this.bufferOffset = 0; // Reset buffer for next frame
+            }
+        }
+    }
+    async popImage() {
+        if (this.imageBuffers.length) {
+            const image = this.imageBuffers.shift();
+            this.framesProcessed++;
+            this.lastImage = image;
+            return image;
+        }
+        if (this.state === 'error') {
+            throw new Error('An error occurred while extracting the video frames.');
+        }
+        // If the video is done and there are no more frames to extract, return the last frame.
+        if (this.state === 'done' && this.toTime >= this.duration) {
+            return this.lastImage;
+        }
+        // If there are more frames to extract, request the next chunk.
+        if (this.state === 'done') {
+            this.startTime = this.toTime;
+            this.toTime = Math.min(this.startTime + VideoFrameExtractor.chunkLengthInSeconds, this.duration);
+            if (!this.codec) {
+                throw new Error("Can't extract frames without a codec. This error should never happen.");
+            }
+            this.process = this.createFfmpegProcess(this.startTime, this.toTime, this.downloadedFilePath, this.fps, this.codec);
+            this.state = 'processing';
+        }
+        while (this.imageBuffers.length < 1) {
+            await new Promise(resolve => setTimeout(resolve, 50));
+        }
+        const image = this.imageBuffers.shift();
+        this.framesProcessed++;
+        this.lastImage = image;
+        return image;
+    }
+    handleClose(code) {
+        this.state = code === 0 ? 'done' : 'error';
+    }
+    async handleError(err) {
+        const code = err.code;
+        if (this.terminated) {
+            return;
+        }
+        if (code === 'ENOENT') {
+            (0, telemetry_1.sendEvent)(telemetry_1.EventName.Error, { error: 'ffmpeg-not-found' });
+            throw new Error('Error: ffmpeg not found. Make sure ffmpeg is installed on your system.');
+        }
+        else if (err.message.includes('SIGSEGV')) {
+            (0, telemetry_1.sendEvent)(telemetry_1.EventName.Error, {
+                error: 'ffmpeg-sigsegv',
+                message: err.message,
+            });
+            throw new Error(`Error: Segmentation fault when running ffmpeg. This is a common issue on Linux, you might be able to fix it by installing nscd ('sudo apt-get install nscd'). For more information, see https://docs.re.video/common-issues/ffmpeg/`);
+        }
+        else {
+            await (0, telemetry_1.sendEvent)(telemetry_1.EventName.Error, {
+                error: 'ffmpeg-error',
+                message: err.message,
+            });
+            throw new Error(`An ffmpeg error occurred while fetching frames from source video ${this.filePath}: ${err}`);
+        }
+    }
+    destroy() {
+        this.terminated = true;
+        this.process?.kill('SIGTERM');
+    }
+}
+exports.VideoFrameExtractor = VideoFrameExtractor;
+VideoFrameExtractor.chunkLengthInSeconds = 5;
+VideoFrameExtractor.downloadedVideoMap = new Map();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"video-frame-extractor.js","sourceRoot":"","sources":["../src/video-frame-extractor.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@twick/ffmpeg",
+  "version": "0.11.0",
+  "description": "Ffmpeg utilities for twick",
+  "main": "dist/index.js",
+  "author": "twick",
+  "homepage": "https://re.video/",
+  "bugs": "https://github.com/ncounterspecialist/twick-base/issues",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc"
+  },
+  "files": [
+    "dist",
+    "types"
+  ],
+  "dependencies": {
+    "@ffmpeg-installer/ffmpeg": "^1.1.0",
+    "@ffprobe-installer/ffprobe": "^2.0.0",
+    "@twick/core": "^0.11.0",
+    "@twick/telemetry": "^0.11.0",
+    "fluent-ffmpeg": "^2.1.2",
+    "uuid": "^10.0.0"
+  },
+  "devDependencies": {
+    "@types/ffprobe-static": "^2.0.3",
+    "@types/fluent-ffmpeg": "^2.1.21",
+    "@types/uuid": "^10.0.0"
+  },
+  "gitHead": "59f38f4e7d3a9a30943bbad830dc0201eaa57ce7"
+}