ffmpeg-progress 1.2.2 → 1.4.0

package/README.md

@@ -42,6 +42,15 @@ await convertFile({
 timer.end()
 ```
 
+**Get video resolution**:
+
+```typescript
+import { getVideoResolution } from 'ffmpeg-progress'
+
+console.log(await getVideoResolution('test/rotate.mp4'))
+// { width: 3024, height: 4032 }
+```
+
 ## Typescript Types
 
 ```typescript
@@ -88,6 +97,16 @@ export function attachChildProcess(
     childProcess: ChildProcessWithoutNullStreams
   } & ProgressArgs,
 ): Promise<void>
+
+/**
+ * take a image frame from the video,
+ * this is more accurate than parsing the resolution string in ffmpeg,
+ * because the video has rotation metadata.
+ */
+export function getVideoResolution(video_file: string): Promise<{
+  width: number
+  height: number
+}>
 ```
 
 ## License

package/core.d.ts

@@ -15,8 +15,14 @@ export type ScanVideoResult = {
     duration: string;
     /** @description e.g. 180.03 or 0 */
     seconds: number;
-    /** @description e.g. "4032x3024" */
-    resolution: string;
+    /**
+     * @description e.g. "4032x3024"
+     * This is the stored resolution of the video, not the resolution of the video when it is played.
+     * The display image may be rotated if there are rotation metadata in the video.
+     */
+    resolution: string | null;
+    /** @description e.g. 44100 for 44.1kHz */
+    audioSampleRate: number | null;
 };
 export declare function parseVideoMetadata(stdout: string): ScanVideoResult;
 export declare function scanVideo(file: string): Promise<ScanVideoResult>;
@@ -47,3 +53,12 @@ export declare function estimateOutSize(args: {
     currentSeconds: number;
     totalSeconds: number;
 }): number;
+/**
+ * take a image frame from the video,
+ * this is more accurate than parsing the resolution string in ffmpeg,
+ * because the video has rotation metadata.
+ */
+export declare function getVideoResolution(video_file: string): Promise<{
+    width: number;
+    height: number;
+}>;

package/core.js

@@ -7,7 +7,10 @@ exports.scanVideo = scanVideo;
 exports.convertFile = convertFile;
 exports.attachChildProcess = attachChildProcess;
 exports.estimateOutSize = estimateOutSize;
+exports.getVideoResolution = getVideoResolution;
 const child_process_1 = require("child_process");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
 /** @description
  * from "00:01:00.03" to 60.03;
  * from "N/A" to NaN;
@@ -68,9 +71,10 @@ function format_ms(ms) {
 let duration_regex = /Duration: ([0-9:.]+|N\/A),/;
 // e.g. "  Stream #0:0[0x1](und): Video: h264 (Baseline) (avc1 / 0x31637661), yuvj420p(pc, progressive), 4032x3024, 2045 kb/s, 29.73 fps, 600 tbr, 600 tbn (default)"
 // e.g. "  Stream #0:0[0x1](eng): Video: h264 (High) (avc1 / 0x31637661), yuv420p(tv, bt470bg/unknown/unknown, progressive), 1920x1080 [SAR 1:1 DAR 16:9], 3958 kb/s, 29.49 fps, 29.83 tbr, 11456 tbn (default)"
-// e.g. "  Stream #0:0: Audio: mp3 (mp3float), 44100 Hz, stereo, fltp, 128 kb/s"
 // e.g. "  Stream #0:1: Video: flv1 (flv), yuv420p, 1080x1920, 200 kb/s, 60 fps, 60 tbr, 1k tbn"
 let resolution_regex = /Stream #0:\d[\w\[\]\(\)]*: Video: .+ (\d+x\d+)[\s|,]/;
+// e.g. "  Stream #0:0: Audio: mp3 (mp3float), 44100 Hz, stereo, fltp, 128 kb/s"
+let audio_sample_rate_regex = /Stream #0:\d[\w\[\]\(\)]*: Audio: .+ (\d+) Hz/;
 function parseVideoMetadata(stdout) {
     let lines = stdout
         .split('\n')
@@ -82,13 +86,36 @@ function parseVideoMetadata(stdout) {
     }
     let duration = match[1];
     let seconds = parseToSeconds(duration);
+    let resolution = parseResolution(lines);
+    let audioSampleRate = parseAudioSampleRate(lines);
+    return { duration, seconds, resolution, audioSampleRate };
+}
+function parseResolution(lines) {
+    let has_video = lines.find(line => line.trim().startsWith('Stream #0:') && line.includes(' Video: '));
+    if (!has_video)
+        return null;
     let line = lines.find(line => resolution_regex.test(line));
-    match = line?.match(resolution_regex);
+    let match = line?.match(resolution_regex);
     if (!match) {
         throw new Error('failed to find video resolution');
     }
     let resolution = match[1];
-    return { duration, seconds, resolution };
+    return resolution;
+}
+function parseAudioSampleRate(lines) {
+    let has_audio = lines.find(line => line.trim().startsWith('Stream #0:') && line.includes(' Audio: '));
+    if (!has_audio)
+        return null;
+    let line = lines.find(line => audio_sample_rate_regex.test(line));
+    let match = line?.match(audio_sample_rate_regex);
+    if (!match) {
+        throw new Error('failed to find audio sample rate');
+    }
+    let audioSampleRate = +match[1];
+    if (!audioSampleRate) {
+        throw new Error(`failed to parse audio sample rate: ${JSON.stringify(match[1])}`);
+    }
+    return audioSampleRate;
 }
 function scanVideo(file) {
     return new Promise((resolve, reject) => {
@@ -170,3 +197,68 @@ function estimateOutSize(args) {
     let estimatedOutSize = args.currentOutSize + estimatedRate * remindSeconds;
     return estimatedOutSize;
 }
+/**
+ * take a image frame from the video,
+ * this is more accurate than parsing the resolution string in ffmpeg,
+ * because the video has rotation metadata.
+ */
+async function getVideoResolution(video_file) {
+    let image_file = (0, path_1.join)('/tmp/', (0, path_1.basename)(video_file) + '.jpg');
+    // ffmpeg -ss 0 -i video.mp4 -frames:v 1 -f image2 -update 1 -y image.jpg
+    let childProcess = (0, child_process_1.spawn)('ffmpeg', [
+        '-ss',
+        '0',
+        '-i',
+        video_file,
+        '-frames:v',
+        '1',
+        '-f',
+        'image2',
+        '-update',
+        '1',
+        '-y',
+        image_file,
+    ]);
+    var { stdout, stderr, code, signal } = await waitChildProcess(childProcess);
+    if (code != 0) {
+        throw new Error(`ffmpeg exit abnormally, exit code: ${code}, signal: ${signal}, stdout: ${stdout}, stderr: ${stderr}`);
+    }
+    childProcess = (0, child_process_1.spawn)('file', [image_file]);
+    var { stdout, stderr, code, signal } = await waitChildProcess(childProcess);
+    if (code != 0) {
+        throw new Error(`file exit abnormally, exit code: ${code}, signal: ${signal}, stdout: ${stdout}, stderr: ${stderr}`);
+    }
+    let resolution = parseImageResolution(stdout);
+    await (0, promises_1.unlink)(image_file);
+    return resolution;
+}
+function waitChildProcess(childProcess) {
+    return new Promise((resolve, reject) => {
+        let stdout = '';
+        let stderr = '';
+        childProcess.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        childProcess.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        childProcess.on('exit', (code, signal) => {
+            resolve({ stdout, stderr, code, signal });
+        });
+    });
+}
+// e.g. sample.jpg: JPEG image data, baseline, precision 8, 3024x4032, components 3
+function parseImageResolution(text) {
+    let parts = text.split(', ').reverse();
+    for (let part of parts) {
+        let parts = part.split('x');
+        if (parts.length == 2) {
+            let width = +parts[0];
+            let height = +parts[1];
+            if (width && height) {
+                return { width, height };
+            }
+        }
+    }
+    throw new Error('failed to parse image resolution: ' + JSON.stringify(text));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ffmpeg-progress",
-  "version": "1.2.2",
+  "version": "1.4.0",
   "description": "Extract progress from ffmpeg child_process",
   "keywords": [
     "ffmpeg",