ffmpeg-progress 1.5.0 → 1.7.0

package/README.md

@@ -42,6 +42,54 @@ await convertFile({
 timer.end()
 ```
 
+**Convert video with custom FFmpeg arguments**:
+
+```typescript
+import { convertFile } from 'ffmpeg-progress'
+
+// H.264 codec with YUV420p pixel format and 2000k bitrate
+await convertFile({
+  inFile: 'input.mp4',
+  outFile: 'output.mp4',
+  ffmpegArgs: ['-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-b:v', '2000k'],
+})
+
+// Resize video - Scale to 720p
+await convertFile({
+  inFile: 'input.mp4',
+  outFile: 'output.mp4',
+  ffmpegArgs: ['-vf', 'scale=1280:720'],
+})
+
+// Extract audio - Convert video to MP3
+await convertFile({
+  inFile: 'input.mp4',
+  outFile: 'output.mp3',
+  ffmpegArgs: ['-vn', '-acodec', 'libmp3lame', '-ab', '192k'],
+})
+
+// Quality preset - Use H.264 with slow preset and CRF quality
+await convertFile({
+  inFile: 'input.mp4',
+  outFile: 'output.mp4',
+  ffmpegArgs: ['-c:v', 'libx264', '-preset', 'slow', '-crf', '23'],
+})
+```
+
+**Rotate video**:
+
+```typescript
+import { rotateVideo } from 'ffmpeg-progress'
+
+await rotateVideo({
+  inFile: 'test/in.mp4',
+  outFile: 'test/rotated.mp4',
+  angle: 90, // Rotate 90° clockwise (or 180, 270)
+})
+```
+
+Progress monitoring is also available similar to `convertFile` using `onDuration`, `onProgress`, etc.
+
 **Get video resolution**:
 
 ```typescript
@@ -98,6 +146,16 @@ export function convertFile(
   args: {
     inFile: string
     outFile: string
+    ffmpegArgs?: string[]
+  } & ProgressArgs,
+): Promise<void>
+
+export function rotateVideo(
+  args: {
+    inFile: string
+    outFile: string
+    /** degrees to rotate in clockwise direction */
+    angle: 90 | 180 | 270
   } & ProgressArgs,
 ): Promise<void>
 

package/bin.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('./cli')

package/cli.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const core_1 = require("./core");
+let args = process.argv.slice(2);
+for (let arg of args) {
+    if (arg == '-h' || arg == '--help') {
+        console.log(`
+ffmpeg-progress - A progress monitor for FFmpeg operations
+
+USAGE:
+  ffmpeg-progress <option>
+  ffmpeg-progress <ffmpeg-args...>
+  ffmpeg <ffmpeg-args...> 2>&1 | ffmpeg-progress
+
+EXAMPLES:
+  # as drop-in replacement for ffmpeg:
+  ffmpeg-progress -i input.mp4 -c:v libx264 output.mp4
+
+  # pipe from ffmpeg output (need to redirect stderr):
+  ffmpeg -i input.mp4 -c:v libx264 output.mp4 2>&1 | ffmpeg-progress
+
+OPTIONS:
+  -h, --help     show this help message and exit
+  -v, --version  show version and exit
+
+NOTES:
+  - Pipe mode requires redirecting ffmpeg stderr to stdout (2>&1)
+  - Wrapped mode automatically captures ffmpeg progress from stderr
+  - ffmpeg outputs progress information to stderr, not stdout
+`.trim());
+        process.exit(0);
+    }
+    if (arg == '-version' || arg == '--version') {
+        let pkg = require('./package.json');
+        console.log(`ffmpeg-progress ${pkg.version}`);
+        process.exit(0);
+    }
+}
+let errorLines = [];
+function checkOverwrite(chunk) {
+    let str = chunk.toString();
+    if (str.includes('Overwrite?')) {
+        console.error(str);
+        return;
+    }
+    errorLines.push(str);
+}
+function f(time) {
+    return (0, core_1.secondsToString)(Math.round(time));
+}
+let lastMessageLength = 0;
+function writeProgress(message) {
+    let output = '\r' + message.padEnd(lastMessageLength, ' ');
+    lastMessageLength = message.length;
+    process.stdout.write(output);
+}
+let startTime = 0;
+function onProgress(args) {
+    startTime ||= Date.now();
+    let passedTime = Date.now() - startTime;
+    let progress = `${f(args.currentSeconds)}/${f(args.totalSeconds)}`;
+    let speed = (args.currentSeconds / (passedTime / 1000)).toFixed(1);
+    let elapsed = f(passedTime / 1000);
+    let eta = f((args.totalSeconds - args.currentSeconds) /
+        (args.currentSeconds / (passedTime / 1000)));
+    writeProgress(`progress=${progress} speed=${speed}x elapsed=${elapsed} eta=${eta}`);
+}
+if (args.length == 0) {
+    console.log('reading ffmpeg output from pipe...');
+    (0, core_1.attachStream)({
+        stream: process.stdin,
+        onData: checkOverwrite,
+        onProgress,
+    }).on('end', () => {
+        process.stdout.write('\n');
+        console.log('end of ffmpeg output.');
+    });
+}
+else {
+    let cmd = 'ffmpeg';
+    for (let arg of args) {
+        let str = JSON.stringify(arg);
+        if (str == `"${arg}"`) {
+            cmd += ' ' + arg;
+        }
+        else {
+            cmd += ' ' + str;
+        }
+    }
+    console.log('> ' + cmd);
+    let childProcess = (0, child_process_1.spawn)('ffmpeg', args, {
+        stdio: ['inherit', 'pipe', 'pipe'],
+    });
+    (0, core_1.attachChildProcess)({
+        childProcess,
+        onStderr: checkOverwrite,
+        onProgress,
+    })
+        .then(() => {
+        process.stdout.write('\n');
+        console.log('ffmpeg process finished.');
+    })
+        .catch(error => {
+        process.stderr.write('\n');
+        for (let line of errorLines) {
+            console.error(line);
+        }
+        console.error('ffmpeg process error:', error);
+        process.exit(1);
+    });
+}

package/core.d.ts

@@ -1,4 +1,5 @@
-import { ChildProcessWithoutNullStreams } from 'child_process';
+import { ChildProcessByStdio, ChildProcessWithoutNullStreams } from 'child_process';
+import Stream from 'stream';
 /** @description
  * from "00:01:00.03" to 60.03;
  * from "N/A" to NaN;
@@ -27,6 +28,7 @@ export type ScanVideoResult = {
 export declare function parseVideoMetadata(stdout: string): ScanVideoResult;
 export declare function scanVideo(file: string): Promise<ScanVideoResult>;
 export type ProgressArgs = {
+    onStderr?: (chunk: Buffer) => void;
     onData?: (chunk: Buffer) => void;
     onDuration?: (duration: string) => void;
     onTime?: (time: string) => void;
@@ -43,10 +45,22 @@ export type OnProgressArgs = {
 export declare function convertFile(args: {
     inFile: string;
     outFile: string;
+    /** e.g. ['-c:v', 'libx264', '-pix_fmt', 'yuv420p', '-b:v', '2000k'] */
+    ffmpegArgs?: string[];
+} & ProgressArgs): Promise<void>;
+export declare function rotateVideo(args: {
+    inFile: string;
+    outFile: string;
+    /** degrees to rotate in clockwise direction */
+    angle: 90 | 180 | 270;
 } & ProgressArgs): Promise<void>;
 export declare function attachChildProcess(args: {
-    childProcess: ChildProcessWithoutNullStreams;
+    childProcess: ChildProcessWithoutNullStreams | ChildProcessByStdio<null, Stream.Readable, Stream.Readable>;
 } & ProgressArgs): Promise<void>;
+export declare function attachStream(args: {
+    stream: Stream.Readable;
+    abort?: () => void;
+} & ProgressArgs): Stream.Readable;
 export declare function estimateOutSize(args: {
     inSize: number;
     currentOutSize: number;

package/core.js

@@ -5,7 +5,9 @@ exports.secondsToString = secondsToString;
 exports.parseVideoMetadata = parseVideoMetadata;
 exports.scanVideo = scanVideo;
 exports.convertFile = convertFile;
+exports.rotateVideo = rotateVideo;
 exports.attachChildProcess = attachChildProcess;
+exports.attachStream = attachStream;
 exports.estimateOutSize = estimateOutSize;
 exports.getVideoResolution = getVideoResolution;
 exports.getVideoDuration = getVideoDuration;
@@ -136,53 +138,54 @@ function scanVideo(file) {
     });
 }
 async function convertFile(args) {
-    let childProcess = (0, child_process_1.spawn)('ffmpeg', ['-y', '-i', args.inFile, args.outFile]);
+    if (args.inFile === args.outFile) {
+        throw new Error('ffmpeg cannot edit files in-place, input and output file cannot be the same.');
+    }
+    let ffmpegCommand = ['-y', '-i', args.inFile];
+    if (args.ffmpegArgs) {
+        ffmpegCommand.push(...args.ffmpegArgs);
+    }
+    ffmpegCommand.push(args.outFile);
+    let childProcess = (0, child_process_1.spawn)('ffmpeg', ffmpegCommand);
     return attachChildProcess({ childProcess, ...args });
 }
+async function rotateVideo(args) {
+    let filter;
+    switch (args.angle) {
+        case 90:
+            // 90° clockwise
+            filter = 'transpose=1';
+            break;
+        case 180:
+            // 180° rotation
+            filter = 'transpose=1,transpose=1';
+            break;
+        case 270:
+            // 270° clockwise (or 90° counterclockwise)
+            filter = 'transpose=2';
+            break;
+        default:
+            throw new Error(`Unsupported rotation angle: ${args.angle}. Supported angles are 90, 180, or 270 degrees.`);
+    }
+    return convertFile({
+        ...args,
+        ffmpegArgs: ['-vf', filter, '-c:a', 'copy'],
+    });
+}
 async function attachChildProcess(args) {
     let { code, signal } = await new Promise((resolve, reject) => {
         let { childProcess } = args;
-        let duration = '';
-        let time = '';
-        let totalSeconds = 0;
-        let lastSeconds = 0;
         function abort() {
             childProcess.kill('SIGKILL');
         }
         if (args.onData) {
             childProcess.stdout.on('data', args.onData);
         }
-        childProcess.stderr.on('data', (data) => {
-            let str = data.toString();
-            let match = str.match(/Duration: ([0-9:.]+),/);
-            if (match) {
-                duration = match[1];
-                totalSeconds = parseToSeconds(duration);
-                if (args.onDuration) {
-                    args.onDuration(duration);
-                }
-                return;
-            }
-            match = str.match(/frame=\s*\d+\s+fps=.*time=([0-9:.]+)\s/);
-            if (match) {
-                time = match[1];
-                if (args.onTime) {
-                    args.onTime(time);
-                }
-                if (args.onProgress) {
-                    let currentSeconds = parseToSeconds(time);
-                    let deltaSeconds = currentSeconds - lastSeconds;
-                    lastSeconds = currentSeconds;
-                    args.onProgress({
-                        deltaSeconds,
-                        currentSeconds,
-                        totalSeconds,
-                        time,
-                        duration,
-                        abort,
-                    });
-                }
-            }
+        attachStream({
+            stream: childProcess.stderr,
+            onData: undefined,
+            abort,
+            ...args,
         });
         childProcess.on('exit', (code, signal) => {
             resolve({ code, signal });
@@ -192,6 +195,51 @@ async function attachChildProcess(args) {
         return;
     throw new Error(`ffmpeg exit abnormally, exit code: ${code}, signal: ${signal}`);
 }
+function attachStream(args) {
+    let abort = args.abort || (() => { });
+    let duration = '';
+    let time = '';
+    let totalSeconds = 0;
+    let lastSeconds = 0;
+    return args.stream.on('data', (data) => {
+        if (args.onData) {
+            args.onData(data);
+        }
+        if (args.onStderr) {
+            args.onStderr(data);
+        }
+        let str = data.toString();
+        let match = str.match(/Duration: ([0-9:.]+),/);
+        if (match) {
+            duration = match[1];
+            totalSeconds = parseToSeconds(duration);
+            if (args.onDuration) {
+                args.onDuration(duration);
+            }
+            return;
+        }
+        match = str.match(/frame=\s*\d+\s+fps=.*time=([0-9:.]+)\s/);
+        if (match) {
+            time = match[1];
+            if (args.onTime) {
+                args.onTime(time);
+            }
+            if (args.onProgress) {
+                let currentSeconds = parseToSeconds(time);
+                let deltaSeconds = currentSeconds - lastSeconds;
+                lastSeconds = currentSeconds;
+                args.onProgress({
+                    deltaSeconds,
+                    currentSeconds,
+                    totalSeconds,
+                    time,
+                    duration,
+                    abort,
+                });
+            }
+        }
+    });
+}
 function estimateOutSize(args) {
     let estimatedRate = args.currentOutSize / args.currentSeconds;
     let remindSeconds = args.totalSeconds - args.currentSeconds;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ffmpeg-progress",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "Extract progress from ffmpeg child_process",
   "keywords": [
     "ffmpeg",
@@ -29,15 +29,21 @@
   },
   "main": "core.js",
   "types": "./core.d.ts",
+  "bin": {
+    "ffmpeg-progress": "./bin.js"
+  },
   "directories": {
     "test": "test"
   },
   "files": [
+    "bin.js",
+    "cli.js",
     "core.d.ts",
     "core.js"
   ],
   "scripts": {
-    "mocha": "rm -f *.js && ts-mocha \"*.{test,spec}.ts\"",
+    "clean": "rm -f *.js && git checkout bin.js",
+    "mocha": "npm run clean && ts-mocha \"*.{test,spec}.ts\"",
     "test": "npm run mocha && tsc --noEmit",
     "build": "tsc -p ."
   },