initial
This commit is contained in:
750
ts/classes.smartffmpeg.ts
Normal file
750
ts/classes.smartffmpeg.ts
Normal file
@@ -0,0 +1,750 @@
|
||||
import * as plugins from './plugins.js';
|
||||
import type * as interfaces from './interfaces.js';
|
||||
import { FfmpegCommand, type TFfmpegInput, type IInputOptions } from './classes.ffmpegcommand.js';
|
||||
|
||||
/**
|
||||
* Event callback types
|
||||
*/
|
||||
export type TProgressCallback = (progress: interfaces.IProgressInfo) => void;
|
||||
export type TErrorCallback = (error: Error) => void;
|
||||
export type TEndCallback = () => void;
|
||||
|
||||
/**
|
||||
* SmartFfmpeg - A fast Node.js module for media file conversion using ffmpeg
|
||||
*
|
||||
* @example Modern Builder API
|
||||
* ```typescript
|
||||
* const ffmpeg = new SmartFfmpeg();
|
||||
*
|
||||
* // File to file with fluent API
|
||||
* await ffmpeg.create()
|
||||
* .input('/path/to/input.mp4')
|
||||
* .videoCodec('libx264')
|
||||
* .audioBitrate('128k')
|
||||
* .size(1920, 1080)
|
||||
* .output('/path/to/output.mp4')
|
||||
* .run();
|
||||
*
|
||||
* // Buffer to buffer
|
||||
* const outputBuffer = await ffmpeg.create()
|
||||
* .input(inputBuffer, { format: 'mp4' })
|
||||
* .videoCodec('libx264')
|
||||
* .toBuffer('webm');
|
||||
*
|
||||
* // With progress tracking
|
||||
* await ffmpeg.create()
|
||||
* .input('/path/to/input.mp4')
|
||||
* .videoCodec('libx264')
|
||||
* .onProgress(p => console.log(`${p.percent?.toFixed(1)}%`))
|
||||
* .output('/path/to/output.mp4')
|
||||
* .run();
|
||||
*
|
||||
* // Stream output
|
||||
* const stream = ffmpeg.create()
|
||||
* .input('/path/to/input.mp4')
|
||||
* .videoCodec('libx264')
|
||||
* .toStream('mp4');
|
||||
* ```
|
||||
*
|
||||
* @example Legacy API (still supported)
|
||||
* ```typescript
|
||||
* await ffmpeg.convert('input.mp4', 'output.webm', {
|
||||
* videoCodec: 'libvpx-vp9',
|
||||
* audioBitrate: '128k'
|
||||
* });
|
||||
* ```
|
||||
*/
|
||||
export class SmartFfmpeg {
|
||||
private ffmpegPath: string;
|
||||
private ffprobePath: string;
|
||||
|
||||
constructor() {
|
||||
this.ffmpegPath = plugins.ffmpegBinaryPath;
|
||||
this.ffprobePath = plugins.ffprobeBinaryPath;
|
||||
}
|
||||
|
||||
// ==================== BUILDER API ====================
|
||||
|
||||
/**
|
||||
* Create a new FfmpegCommand builder for fluent API usage
|
||||
*
|
||||
* @example
|
||||
* ```typescript
|
||||
* await ffmpeg.create()
|
||||
* .input('/path/to/input.mp4')
|
||||
* .videoCodec('libx264')
|
||||
* .crf(23)
|
||||
* .output('/path/to/output.mp4')
|
||||
* .run();
|
||||
* ```
|
||||
*/
|
||||
create(): FfmpegCommand {
|
||||
return new FfmpegCommand(this.ffmpegPath, this.ffprobePath);
|
||||
}
|
||||
|
||||
/**
|
||||
* Shorthand to create a command with input already set
|
||||
*
|
||||
* @example
|
||||
* ```typescript
|
||||
* // File input
|
||||
* await ffmpeg.input('/path/to/input.mp4')
|
||||
* .videoCodec('libx264')
|
||||
* .output('/path/to/output.mp4')
|
||||
* .run();
|
||||
*
|
||||
* // Buffer input
|
||||
* const output = await ffmpeg.input(buffer, { format: 'mp4' })
|
||||
* .videoCodec('libx264')
|
||||
* .toBuffer('webm');
|
||||
* ```
|
||||
*/
|
||||
input(source: TFfmpegInput, options?: IInputOptions): FfmpegCommand {
|
||||
return this.create().input(source, options);
|
||||
}
|
||||
|
||||
// ==================== LEGACY API ====================
|
||||
|
||||
/**
|
||||
* Get media file information using ffprobe
|
||||
*/
|
||||
public async getMediaInfo(inputPath: string): Promise<interfaces.IMediaInfo> {
|
||||
const args = [
|
||||
'-v', 'quiet',
|
||||
'-print_format', 'json',
|
||||
'-show_format',
|
||||
'-show_streams',
|
||||
inputPath
|
||||
];
|
||||
|
||||
const result = await this.runProcess(this.ffprobePath, args);
|
||||
const data = JSON.parse(result.stdout);
|
||||
|
||||
return {
|
||||
format: {
|
||||
filename: data.format.filename,
|
||||
formatName: data.format.format_name,
|
||||
formatLongName: data.format.format_long_name,
|
||||
duration: parseFloat(data.format.duration) || 0,
|
||||
size: parseInt(data.format.size, 10) || 0,
|
||||
bitrate: parseInt(data.format.bit_rate, 10) || 0,
|
||||
},
|
||||
streams: (data.streams || []).map((stream: any) => this.parseStreamInfo(stream)),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert media file with specified options
|
||||
*/
|
||||
public async convert(
|
||||
inputPath: string,
|
||||
outputPath: string,
|
||||
options: interfaces.IConversionOptions = {}
|
||||
): Promise<void> {
|
||||
const args = this.buildConversionArgs(inputPath, outputPath, options);
|
||||
await this.runProcess(this.ffmpegPath, args);
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert media file with progress reporting
|
||||
*/
|
||||
public async convertWithProgress(
|
||||
inputPath: string,
|
||||
outputPath: string,
|
||||
options: interfaces.IConversionOptions = {},
|
||||
onProgress?: TProgressCallback
|
||||
): Promise<void> {
|
||||
// Get duration for progress percentage calculation
|
||||
let totalDuration: number | undefined;
|
||||
try {
|
||||
const info = await this.getMediaInfo(inputPath);
|
||||
totalDuration = info.format.duration;
|
||||
} catch {
|
||||
// Continue without duration info
|
||||
}
|
||||
|
||||
const args = ['-progress', 'pipe:1', ...this.buildConversionArgs(inputPath, outputPath, options)];
|
||||
|
||||
return new Promise((resolve, reject) => {
|
||||
const process = plugins.child_process.spawn(this.ffmpegPath, args);
|
||||
|
||||
let progressData: Partial<interfaces.IProgressInfo> = {};
|
||||
|
||||
process.stdout?.on('data', (data: Buffer) => {
|
||||
const lines = data.toString().split('\n');
|
||||
for (const line of lines) {
|
||||
const [key, value] = line.split('=');
|
||||
if (!key || !value) continue;
|
||||
|
||||
switch (key.trim()) {
|
||||
case 'frame':
|
||||
progressData.frame = parseInt(value, 10);
|
||||
break;
|
||||
case 'fps':
|
||||
progressData.fps = parseFloat(value);
|
||||
break;
|
||||
case 'total_size':
|
||||
progressData.size = parseInt(value, 10);
|
||||
break;
|
||||
case 'out_time_ms':
|
||||
progressData.time = parseInt(value, 10) / 1000000;
|
||||
if (totalDuration && progressData.time) {
|
||||
progressData.percent = Math.min(100, (progressData.time / totalDuration) * 100);
|
||||
}
|
||||
break;
|
||||
case 'bitrate':
|
||||
progressData.bitrate = value.trim();
|
||||
break;
|
||||
case 'speed':
|
||||
progressData.speed = value.trim();
|
||||
break;
|
||||
case 'progress':
|
||||
if (value.trim() === 'continue' || value.trim() === 'end') {
|
||||
if (onProgress && progressData.frame !== undefined) {
|
||||
onProgress(progressData as interfaces.IProgressInfo);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let stderr = '';
|
||||
process.stderr?.on('data', (data: Buffer) => {
|
||||
stderr += data.toString();
|
||||
});
|
||||
|
||||
process.on('close', (code) => {
|
||||
if (code === 0) {
|
||||
resolve();
|
||||
} else {
|
||||
reject(new Error(`FFmpeg exited with code ${code}: ${stderr}`));
|
||||
}
|
||||
});
|
||||
|
||||
process.on('error', (err) => {
|
||||
reject(err);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Extract audio from video file
|
||||
*/
|
||||
public async extractAudio(
|
||||
inputPath: string,
|
||||
outputPath: string,
|
||||
options: Pick<interfaces.IConversionOptions, 'audioCodec' | 'audioBitrate' | 'sampleRate' | 'audioChannels' | 'startTime' | 'duration' | 'overwrite'> = {}
|
||||
): Promise<void> {
|
||||
const conversionOptions: interfaces.IConversionOptions = {
|
||||
...options,
|
||||
noVideo: true,
|
||||
};
|
||||
await this.convert(inputPath, outputPath, conversionOptions);
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove audio from video file
|
||||
*/
|
||||
public async removeAudio(
|
||||
inputPath: string,
|
||||
outputPath: string,
|
||||
options: Pick<interfaces.IConversionOptions, 'videoCodec' | 'videoBitrate' | 'overwrite'> = {}
|
||||
): Promise<void> {
|
||||
const conversionOptions: interfaces.IConversionOptions = {
|
||||
...options,
|
||||
noAudio: true,
|
||||
};
|
||||
await this.convert(inputPath, outputPath, conversionOptions);
|
||||
}
|
||||
|
||||
/**
|
||||
* Take a screenshot at a specific time
|
||||
*/
|
||||
public async screenshot(
|
||||
inputPath: string,
|
||||
outputPath: string,
|
||||
options: interfaces.IScreenshotOptions
|
||||
): Promise<void> {
|
||||
const args: string[] = [
|
||||
'-y',
|
||||
'-ss', this.formatTime(options.time),
|
||||
'-i', inputPath,
|
||||
'-vframes', '1',
|
||||
];
|
||||
|
||||
if (options.width || options.height) {
|
||||
const scale = this.buildScaleFilter(options.width, options.height);
|
||||
args.push('-vf', scale);
|
||||
}
|
||||
|
||||
if (options.format === 'jpg' && options.quality) {
|
||||
args.push('-q:v', String(Math.round((100 - options.quality) / 100 * 31)));
|
||||
} else if (options.format === 'webp' && options.quality) {
|
||||
args.push('-quality', String(options.quality));
|
||||
}
|
||||
|
||||
args.push(outputPath);
|
||||
await this.runProcess(this.ffmpegPath, args);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate multiple thumbnails from video
|
||||
*/
|
||||
public async generateThumbnails(
|
||||
inputPath: string,
|
||||
outputDir: string,
|
||||
options: interfaces.IThumbnailOptions
|
||||
): Promise<string[]> {
|
||||
const info = await this.getMediaInfo(inputPath);
|
||||
const duration = info.format.duration;
|
||||
const interval = duration / (options.count + 1);
|
||||
|
||||
const pattern = options.filenamePattern || 'thumb_%d';
|
||||
const ext = options.format || 'png';
|
||||
const outputPaths: string[] = [];
|
||||
|
||||
for (let i = 1; i <= options.count; i++) {
|
||||
const time = interval * i;
|
||||
const filename = pattern.replace('%d', String(i).padStart(3, '0')) + '.' + ext;
|
||||
const outputPath = plugins.path.join(outputDir, filename);
|
||||
|
||||
await this.screenshot(inputPath, outputPath, {
|
||||
time,
|
||||
width: options.width,
|
||||
height: options.height,
|
||||
format: options.format,
|
||||
});
|
||||
|
||||
outputPaths.push(outputPath);
|
||||
}
|
||||
|
||||
return outputPaths;
|
||||
}
|
||||
|
||||
/**
|
||||
* Resize video
|
||||
*/
|
||||
public async resize(
|
||||
inputPath: string,
|
||||
outputPath: string,
|
||||
width?: number,
|
||||
height?: number,
|
||||
options: Omit<interfaces.IConversionOptions, 'width' | 'height'> = {}
|
||||
): Promise<void> {
|
||||
await this.convert(inputPath, outputPath, { ...options, width, height });
|
||||
}
|
||||
|
||||
/**
|
||||
* Change video frame rate
|
||||
*/
|
||||
public async changeFrameRate(
|
||||
inputPath: string,
|
||||
outputPath: string,
|
||||
fps: number,
|
||||
options: Omit<interfaces.IConversionOptions, 'fps'> = {}
|
||||
): Promise<void> {
|
||||
await this.convert(inputPath, outputPath, { ...options, fps });
|
||||
}
|
||||
|
||||
/**
|
||||
* Trim media file
|
||||
*/
|
||||
public async trim(
|
||||
inputPath: string,
|
||||
outputPath: string,
|
||||
startTime: number | string,
|
||||
duration: number | string,
|
||||
options: Omit<interfaces.IConversionOptions, 'startTime' | 'duration'> = {}
|
||||
): Promise<void> {
|
||||
await this.convert(inputPath, outputPath, { ...options, startTime, duration });
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert to GIF
|
||||
*/
|
||||
public async toGif(
|
||||
inputPath: string,
|
||||
outputPath: string,
|
||||
options: {
|
||||
width?: number;
|
||||
height?: number;
|
||||
fps?: number;
|
||||
startTime?: number | string;
|
||||
duration?: number | string;
|
||||
} = {}
|
||||
): Promise<void> {
|
||||
const args: string[] = ['-y'];
|
||||
|
||||
if (options.startTime !== undefined) {
|
||||
args.push('-ss', this.formatTime(options.startTime));
|
||||
}
|
||||
|
||||
args.push('-i', inputPath);
|
||||
|
||||
if (options.duration !== undefined) {
|
||||
args.push('-t', this.formatTime(options.duration));
|
||||
}
|
||||
|
||||
// Build filter for GIF optimization
|
||||
const filters: string[] = [];
|
||||
|
||||
if (options.fps) {
|
||||
filters.push(`fps=${options.fps}`);
|
||||
}
|
||||
|
||||
if (options.width || options.height) {
|
||||
filters.push(this.buildScaleFilter(options.width, options.height));
|
||||
}
|
||||
|
||||
// Split filter for palette generation (better GIF quality)
|
||||
filters.push('split[s0][s1]');
|
||||
filters.push('[s0]palettegen[p]');
|
||||
filters.push('[s1][p]paletteuse');
|
||||
|
||||
args.push('-filter_complex', filters.join(','));
|
||||
args.push(outputPath);
|
||||
|
||||
await this.runProcess(this.ffmpegPath, args);
|
||||
}
|
||||
|
||||
/**
|
||||
* Concatenate multiple media files
|
||||
*/
|
||||
public async concat(
|
||||
inputPaths: string[],
|
||||
outputPath: string,
|
||||
options: interfaces.IConversionOptions = {}
|
||||
): Promise<void> {
|
||||
// Create concat file content
|
||||
const concatContent = inputPaths
|
||||
.map(p => `file '${p.replace(/'/g, "'\\''")}'`)
|
||||
.join('\n');
|
||||
|
||||
// Write to temp file
|
||||
const tempFile = plugins.path.join(
|
||||
plugins.path.dirname(outputPath),
|
||||
`.concat_${Date.now()}.txt`
|
||||
);
|
||||
|
||||
// Write concat file using SmartFs
|
||||
const fs = new plugins.smartfs.SmartFs(new plugins.smartfs.SmartFsProviderNode());
|
||||
await fs.file(tempFile).write(concatContent);
|
||||
|
||||
try {
|
||||
const args: string[] = [
|
||||
'-y',
|
||||
'-f', 'concat',
|
||||
'-safe', '0',
|
||||
'-i', tempFile,
|
||||
];
|
||||
|
||||
if (options.videoCodec) {
|
||||
args.push('-c:v', options.videoCodec);
|
||||
} else {
|
||||
args.push('-c', 'copy');
|
||||
}
|
||||
|
||||
if (options.audioCodec) {
|
||||
args.push('-c:a', options.audioCodec);
|
||||
}
|
||||
|
||||
args.push(outputPath);
|
||||
await this.runProcess(this.ffmpegPath, args);
|
||||
} finally {
|
||||
// Clean up temp file
|
||||
await fs.file(tempFile).delete();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Add audio to video
|
||||
*/
|
||||
public async addAudio(
|
||||
videoPath: string,
|
||||
audioPath: string,
|
||||
outputPath: string,
|
||||
options: {
|
||||
videoCodec?: interfaces.TVideoCodec;
|
||||
audioCodec?: interfaces.TAudioCodec;
|
||||
audioBitrate?: string;
|
||||
shortest?: boolean;
|
||||
overwrite?: boolean;
|
||||
} = {}
|
||||
): Promise<void> {
|
||||
const args: string[] = [
|
||||
'-y',
|
||||
'-i', videoPath,
|
||||
'-i', audioPath,
|
||||
'-c:v', options.videoCodec || 'copy',
|
||||
'-c:a', options.audioCodec || 'aac',
|
||||
];
|
||||
|
||||
if (options.audioBitrate) {
|
||||
args.push('-b:a', options.audioBitrate);
|
||||
}
|
||||
|
||||
if (options.shortest) {
|
||||
args.push('-shortest');
|
||||
}
|
||||
|
||||
args.push('-map', '0:v:0', '-map', '1:a:0');
|
||||
args.push(outputPath);
|
||||
|
||||
await this.runProcess(this.ffmpegPath, args);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get available encoders
|
||||
*/
|
||||
public async getEncoders(): Promise<string[]> {
|
||||
const result = await this.runProcess(this.ffmpegPath, ['-encoders', '-hide_banner']);
|
||||
const lines = result.stdout.split('\n');
|
||||
const encoders: string[] = [];
|
||||
|
||||
let started = false;
|
||||
for (const line of lines) {
|
||||
if (line.includes('------')) {
|
||||
started = true;
|
||||
continue;
|
||||
}
|
||||
if (started && line.trim()) {
|
||||
const match = line.match(/^\s*[A-Z.]+\s+(\S+)/);
|
||||
if (match) {
|
||||
encoders.push(match[1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return encoders;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get available decoders
|
||||
*/
|
||||
public async getDecoders(): Promise<string[]> {
|
||||
const result = await this.runProcess(this.ffmpegPath, ['-decoders', '-hide_banner']);
|
||||
const lines = result.stdout.split('\n');
|
||||
const decoders: string[] = [];
|
||||
|
||||
let started = false;
|
||||
for (const line of lines) {
|
||||
if (line.includes('------')) {
|
||||
started = true;
|
||||
continue;
|
||||
}
|
||||
if (started && line.trim()) {
|
||||
const match = line.match(/^\s*[A-Z.]+\s+(\S+)/);
|
||||
if (match) {
|
||||
decoders.push(match[1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return decoders;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get available formats
|
||||
*/
|
||||
public async getFormats(): Promise<string[]> {
|
||||
const result = await this.runProcess(this.ffmpegPath, ['-formats', '-hide_banner']);
|
||||
const lines = result.stdout.split('\n');
|
||||
const formats: string[] = [];
|
||||
|
||||
let started = false;
|
||||
for (const line of lines) {
|
||||
if (line.includes('--')) {
|
||||
started = true;
|
||||
continue;
|
||||
}
|
||||
if (started && line.trim()) {
|
||||
const match = line.match(/^\s*[DE ]+\s+(\S+)/);
|
||||
if (match) {
|
||||
formats.push(match[1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return formats;
|
||||
}
|
||||
|
||||
/**
|
||||
* Run ffmpeg with raw arguments
|
||||
*/
|
||||
public async runRaw(args: string[]): Promise<{ stdout: string; stderr: string }> {
|
||||
return this.runProcess(this.ffmpegPath, args);
|
||||
}
|
||||
|
||||
/**
|
||||
* Run ffprobe with raw arguments
|
||||
*/
|
||||
public async runProbeRaw(args: string[]): Promise<{ stdout: string; stderr: string }> {
|
||||
return this.runProcess(this.ffprobePath, args);
|
||||
}
|
||||
|
||||
// ============ Private Methods ============
|
||||
|
||||
private buildConversionArgs(
|
||||
inputPath: string,
|
||||
outputPath: string,
|
||||
options: interfaces.IConversionOptions
|
||||
): string[] {
|
||||
const args: string[] = [];
|
||||
|
||||
// Overwrite flag
|
||||
if (options.overwrite !== false) {
|
||||
args.push('-y');
|
||||
}
|
||||
|
||||
// Input seeking (before -i for fast seeking)
|
||||
if (options.startTime !== undefined) {
|
||||
args.push('-ss', this.formatTime(options.startTime));
|
||||
}
|
||||
|
||||
args.push('-i', inputPath);
|
||||
|
||||
// Duration (after -i)
|
||||
if (options.duration !== undefined) {
|
||||
args.push('-t', this.formatTime(options.duration));
|
||||
}
|
||||
|
||||
// Video options
|
||||
if (options.noVideo) {
|
||||
args.push('-vn');
|
||||
} else {
|
||||
if (options.videoCodec) {
|
||||
args.push('-c:v', options.videoCodec);
|
||||
}
|
||||
if (options.videoBitrate) {
|
||||
args.push('-b:v', options.videoBitrate);
|
||||
}
|
||||
if (options.crf !== undefined) {
|
||||
args.push('-crf', String(options.crf));
|
||||
}
|
||||
if (options.preset) {
|
||||
args.push('-preset', options.preset);
|
||||
}
|
||||
if (options.fps) {
|
||||
args.push('-r', String(options.fps));
|
||||
}
|
||||
if (options.width || options.height) {
|
||||
args.push('-vf', this.buildScaleFilter(options.width, options.height));
|
||||
}
|
||||
}
|
||||
|
||||
// Audio options
|
||||
if (options.noAudio) {
|
||||
args.push('-an');
|
||||
} else {
|
||||
if (options.audioCodec) {
|
||||
args.push('-c:a', options.audioCodec);
|
||||
}
|
||||
if (options.audioBitrate) {
|
||||
args.push('-b:a', options.audioBitrate);
|
||||
}
|
||||
if (options.sampleRate) {
|
||||
args.push('-ar', String(options.sampleRate));
|
||||
}
|
||||
if (options.audioChannels) {
|
||||
args.push('-ac', String(options.audioChannels));
|
||||
}
|
||||
}
|
||||
|
||||
// Output format
|
||||
if (options.format) {
|
||||
args.push('-f', options.format);
|
||||
}
|
||||
|
||||
// Extra arguments
|
||||
if (options.extraArgs) {
|
||||
args.push(...options.extraArgs);
|
||||
}
|
||||
|
||||
args.push(outputPath);
|
||||
|
||||
return args;
|
||||
}
|
||||
|
||||
private buildScaleFilter(width?: number, height?: number): string {
|
||||
const w = width ? String(width) : '-1';
|
||||
const h = height ? String(height) : '-1';
|
||||
// Use -2 instead of -1 to ensure even dimensions (required for some codecs)
|
||||
return `scale=${w === '-1' ? '-2' : w}:${h === '-1' ? '-2' : h}`;
|
||||
}
|
||||
|
||||
private formatTime(time: number | string): string {
|
||||
if (typeof time === 'string') {
|
||||
return time;
|
||||
}
|
||||
// Convert seconds to HH:MM:SS.mmm format
|
||||
const hours = Math.floor(time / 3600);
|
||||
const minutes = Math.floor((time % 3600) / 60);
|
||||
const seconds = time % 60;
|
||||
return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toFixed(3).padStart(6, '0')}`;
|
||||
}
|
||||
|
||||
private parseStreamInfo(stream: any): interfaces.IStreamInfo {
|
||||
const info: interfaces.IStreamInfo = {
|
||||
index: stream.index,
|
||||
codecName: stream.codec_name,
|
||||
codecLongName: stream.codec_long_name,
|
||||
codecType: stream.codec_type,
|
||||
};
|
||||
|
||||
if (stream.codec_type === 'video') {
|
||||
info.width = stream.width;
|
||||
info.height = stream.height;
|
||||
if (stream.r_frame_rate) {
|
||||
const [num, den] = stream.r_frame_rate.split('/').map(Number);
|
||||
info.frameRate = den ? num / den : num;
|
||||
}
|
||||
if (stream.bit_rate) {
|
||||
info.bitrate = parseInt(stream.bit_rate, 10);
|
||||
}
|
||||
}
|
||||
|
||||
if (stream.codec_type === 'audio') {
|
||||
info.sampleRate = parseInt(stream.sample_rate, 10);
|
||||
info.channels = stream.channels;
|
||||
if (stream.bit_rate) {
|
||||
info.bitrate = parseInt(stream.bit_rate, 10);
|
||||
}
|
||||
}
|
||||
|
||||
if (stream.duration) {
|
||||
info.duration = parseFloat(stream.duration);
|
||||
}
|
||||
|
||||
return info;
|
||||
}
|
||||
|
||||
private runProcess(command: string, args: string[]): Promise<{ stdout: string; stderr: string }> {
|
||||
return new Promise((resolve, reject) => {
|
||||
const process = plugins.child_process.spawn(command, args);
|
||||
|
||||
let stdout = '';
|
||||
let stderr = '';
|
||||
|
||||
process.stdout?.on('data', (data: Buffer) => {
|
||||
stdout += data.toString();
|
||||
});
|
||||
|
||||
process.stderr?.on('data', (data: Buffer) => {
|
||||
stderr += data.toString();
|
||||
});
|
||||
|
||||
process.on('close', (code) => {
|
||||
if (code === 0) {
|
||||
resolve({ stdout, stderr });
|
||||
} else {
|
||||
reject(new Error(`Process exited with code ${code}: ${stderr}`));
|
||||
}
|
||||
});
|
||||
|
||||
process.on('error', (err) => {
|
||||
reject(err);
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user