文章/答案/技术大牛

发布

社区首页 >专栏 >fluent-ffmpeg详解

fluent-ffmpeg详解

码客说

发布于 2019-10-21 09:16:53

15.4K00

代码可运行

文章被收录于专栏：码客码客

运行总次数：0

代码可运行

官网

库:FFMPEG
播放器: VLC

添加依赖

npm install --save fluent-ffmpeg

或者添加

"dependencies": {
	"fluent-ffmpeg": "^2.1.2"
}

之后

npm install

详解

创建FFmpeg命令

fluent FFmpeg返回一个构造函数，你可以使用它来对FFmpeg命令进行操作。

var FfmpegCommand = require('fluent-ffmpeg');
var command = new FfmpegCommand();

你还可以使用不带 new 运算符的构造函数。

var ffmpeg = require('fluent-ffmpeg');
var command = ffmpeg();

你可以将输入文件 NAME 或者可以读流。配置对象或者两者传递给构造函数。

var command = ffmpeg('/path/to/file.avi');
var command = ffmpeg(fs.createReadStream('/path/to/file.avi'));
var command = ffmpeg({
    option: "value",
    // ...
});
var command = ffmpeg('/path/to/file.avi', {
    option: "value",
    // ...
});

可以使用以下选项：

source: 输入文件 NAME 或者可以读流( 如果传递到构造函数的输入文件被忽略)
timeout: ffmpeg超时秒( 默认为无超时)
( 默认情况下，preset 或者 presets: 从目录加载 MODULE 预设)
在 Windows 和 20之间，niceness 或者 priority: ffmpeg niceness值，在平台上忽略( 默认为4 )
logger: 带有 debug()，info()，warn() 和 error() 方法的记录器对象( 默认为无日志记录)
在内存中保存的ffmpeg/stderr的最大行数( 默认为，使用 0表示无限制存储)。

指定输入

你可以向Ffmpeg命令添加任意数量的输入。输入可以是：

文件 NAME ( ( /path/to/file.avi ) ) ；
一个图像 Pattern ( ( /path/to/frame%03d.png ) )
可以读流；只有一个输入流可以用于命令，但可以同时使用输入流和一个或者多个文件名。

ffmpeg('/path/to/input1.avi')
    .input('/path/to/input2.avi')
    .input(fs.createReadStream('/path/to/input3.avi'));
ffmpeg()
    .input('/path/to/input1.avi')
    .input('/path/to/input2.avi');
ffmpeg()
    .addInput('/path/to/frame%02d.png')
    .addInput('/path/to/soundtrack.mp3');
ffmpeg()
    .mergeAdd('/path/to/input1.avi')
    .mergeAdd('/path/to/input2.avi');

输入选项

以下方法允许将输入相关选项传递给 ffmpeg。这些方法中的每一个都适用于最后一个输入的(。如果有的话，包括传递给构造函数的)。在调用这些内容之前，必须添加输入，否则将引发错误。

inputFormat(format): 指定输入格式

这只对原始输入有用，因为ffmpeg可以自动确定输入格式。

ffmpeg()
    .input('/dev/video0')
    .inputFormat('mov')
    .input('/path/to/file.avi')
    .inputFormat('avi');

流畅的ffmpeg检查在实际运行该命令之前是否可用，并在指定的输入格式不可用时抛出错误。

inputFPS(fps): 指定输入帧数

这只对原始输入有效，因为ffmpeg可以自动确定输入帧数。

ffmpeg('/dev/video0').inputFPS(29.7);

native(): 读取本机帧的输入

ffmpeg('/path/to/file.avi').native();

seekInput(time): 设置输入开始时间

查找输入，仅在给定时间偏移时开始解码。 time 参数可以是数字( 以秒为单位)，也可以是时间戳字符串( 格式为 [[hh:]mm:]ss[.xxx] )。

ffmpeg('/path/to/file.avi').seekInput(134.5);
ffmpeg('/path/to/file.avi').seekInput('2:14.500');

循环( [duration] ): 循环输入

ffmpeg('/path/to/file.avi').loop();
ffmpeg('/path/to/file.avi').loop(134.5);
ffmpeg('/path/to/file.avi').loop('2:14.500');

inputOptions(option…): 添加自定义输入选项

这里方法允许将任何输入相关的选项传递给 ffmpeg。可以使用单个参数调用它，以传递单个选项，也可以使用空格分隔参数：

/* Single option */
ffmpeg('/path/to/file.avi').inputOptions('-someOption');
/* Single option with parameter */
ffmpeg('/dev/video0').inputOptions('-r 24');

你还可以通过将 array 传递给方法来一次传递多个选项：

ffmpeg('/path/to/file.avi').inputOptions([
    '-option1',
    '-option2 param2',
    '-option3',
    '-option4 param4'
]);

最后，你还可以将命令行标记作为单独的参数传递给方法：

ffmpeg('/path/to/file.avi')
    .inputOptions(
        '-option1',
        '-option2', 'param2',
        '-option3',
        '-option4', 'param4'
    );

音频选项

以下方法更改输出输出中的音频流。

noAudio(): 完全禁用音频

在输出中禁用音频，并删除以前设置的音频选项。

ffmpeg('/path/to/file.avi').noAudio();

audioCodec(codec): 设置音频编解码器

ffmpeg('/path/to/file.avi').audioCodec('libmp3lame');

流畅的ffmpeg检查在实际运行该命令之前是否可用，并在指定的音频编解码器不可用时抛出错误。

audioBitrate(bitrate): 设置音频比特率

将音频比特率设置为 kbps。 bitrate 参数可以是一个数字或者带有可选 k 后缀的字符串。这里方法用于强制固定比特率；使用 audioQuality() 可以使用可变比特率进行编码。

ffmpeg('/path/to/file.avi').audioBitrate(128);
ffmpeg('/path/to/file.avi').audioBitrate('128');
ffmpeg('/path/to/file.avi').audioBitrate('128k');

audioChannels(count): 设置音频通道计数

ffmpeg('/path/to/file.avi').audioChannels(2);

audioFrequency(freq): 设置音频频率

freq 参数指定音频频率，单位为 Hz。

ffmpeg('/path/to/file.avi').audioFrequency(22050);

audioQuality(quality): 设置音频质量

这里方法为音频编解码器( VBR编码) 修正了一个品质因素。质量比例取决于实际使用的编解码器。

ffmpeg('/path/to/file.avi')
    .audioCodec('libmp3lame')
    .audioQuality(0);

audioFilters(filter…): 添加自定义音频过滤器

这里方法允许添加自定义音频筛选器。你可以通过传递多个参数或者 array 一次添加多个筛选器。有关可用过滤器及其语法，请参阅Ffmpeg文档。

每个筛选器pased都可以是一个筛选器字符串( 例如。 volume=0.5 ) 或者带有以下键的过滤器规范对象：

filter: 筛选器名称
options: 可选，可以是过滤器的选项字符串( 例如。 n=-50dB:d=5 )，用于未命名选项的选项 array ( 例如。 ['-50dB', 5] ) 或者对象映射选项名( 例如。 { n: '-50dB', d: 5 } )。如果未指定 options，将在没有任何选项的情况下添加筛选器。

ffmpeg('/path/to/file.avi')
    .audioFilters('volume=0.5')
    .audioFilters('silencedetect=n=-50dB:d=5');
ffmpeg('/path/to/file.avi')
    .audioFilters('volume=0.5', 'silencedetect=n=-50dB:d=5');
ffmpeg('/path/to/file.avi')
    .audioFilters(['volume=0.5', 'silencedetect=n=-50dB:d=5']);
ffmpeg('/path/to/file.avi')
    .audioFilters([{
            filter: 'volume',
            options: '0.5'
        },
        {
            filter: 'silencedetect',
            options: 'n=-50dB:d=5'
        }
    ]);
ffmpeg('/path/to/file.avi')
    .audioFilters([{
        filter: 'volume',
        options: ['0.5']
    }, {
        filter: 'silencedetect',
        options: {
            n: '-50dB',
            d: 5
        }
    }]);

视频选项

以下方法将更改所生成输出中的视频流。

noVideo(): 完全禁用视频

这里方法禁用视频输出，并删除以前设置的视频选项。

ffmpeg('/path/to/file.avi').noVideo();

videoCodec(codec): 设置视频编解码器

ffmpeg('/path/to/file.avi').videoCodec('libx264');

流畅的ffmpeg检查在实际运行该命令之前是否可用，并在指定的视频编解码器不可用时抛出错误。

videoBitrate ( 比特率 [, constant=false] ): 设置视频比特率

将目标视频比特率设置为 kbps。 bitrate 参数可以是一个数字或者带有可选 k 后缀的字符串。 constant 参数指定是否应该在( 默认为 false ) 中执行固定比特率。

请记住，根据使用的编解码器，强制一定的比特率经常成为质量的成本。在不损失太多质量的情况下，拥有固定视频比特率的最佳方法是使用 2-pass 编码( 请参阅Fffmpeg文档)。

ffmpeg('/path/to/file.avi').videoBitrate(1000);
ffmpeg('/path/to/file.avi').videoBitrate('1000');
ffmpeg('/path/to/file.avi').videoBitrate('1000k');
ffmpeg('/path/to/file.avi').videoBitrate('1000k', true);

videoFilters(filter…): 添加自定义视频过滤器

这里方法允许添加自定义视频筛选器。你可以通过传递多个参数或者 array 一次添加多个筛选器。有关可用过滤器及其语法，请参阅Ffmpeg文档。

每个筛选器pased都可以是一个筛选器字符串( 例如。 fade=in:0:30 ) 或者带有以下键的过滤器规范对象：

filter: 筛选器名称
options: 可选，可以是过滤器的选项字符串( 例如。 in:0:30 )，用于未命名选项的选项 array ( 例如。 ['in', 0, 30] ) 或者对象映射选项名( 例如。 { t: 'in', s: 0, n: 30 } )。如果未指定 options，将在没有任何选项的情况下添加筛选器。

ffmpeg('/path/to/file.avi')
    .videoFilters('fade=in:0:30')
    .videoFilters('pad=640:480:0:40:violet');

ffmpeg('/path/to/file.avi')
    .videoFilters('fade=in:0:30', 'pad=640:480:0:40:violet');

ffmpeg('/path/to/file.avi')
    .videoFilters(['fade=in:0:30', 'pad=640:480:0:40:violet']);

ffmpeg('/path/to/file.avi')
    .videoFilters([{
            filter: 'fade',
            options: 'in:0:30'
        },
        {
            filter: 'pad',
            options: '640:480:0:40:violet'
        }
    ]);
    
ffmpeg('/path/to/file.avi')
    .videoFilters({
        filter: 'fade',
        options: ['in', 0, 30]
    }, {
        filter: 'filter2',
        options: {
            w: 640,
            h: 480,
            x: 0,
            y: 40,
            color: 'violet'
        }
    });

fps(fps): 设置输出帧数

ffmpeg('/path/to/file.avi').fps(29.7);

frames(count): 指定帧计数

将ffmpeg设置为只编码一定数量的帧。

ffmpeg('/path/to/file.avi').frames(240);

视频帧大小选项

以下方法可以调整输出视频帧大小的大小。它们一起工作，生成合适的视频过滤器。

size(size): 设置输出帧大小

这里方法设置输出帧大小。 size 参数可能具有以下格式之一：

640x480: 设置固定输出帧大小。否则，除非调用 autopad()，否则会导致视频被拉伸或者压缩以适应请求的大小。
640x?: 自动设置固定宽度和计算高度。如果同时调用 aspect()，则用于计算视频高度；否则，将计算它以使输入纵横比保持不变。
?x480: 自动设置高度和计算宽度。如果同时调用 aspect()，则用于计算视频宽度，否则将计算它以使输入纵横比保持不变。
50%: 将宽度和高度重缩放为给定百分比。始终保留纵横比。

注意，为了与某些编解码器兼容，计算的维度总是四舍五入到 2的倍数。

ffmpeg('/path/to/file.avi').size('640x480');
ffmpeg('/path/to/file.avi').size('640x?');
ffmpeg('/path/to/file.avi').size('640x?').aspect('4:3');
ffmpeg('/path/to/file.avi').size('50%');

aspect(aspect): 设置输出帧纵横比

这里方法强制指定输出纵横比。 aspect 参数可以是数字，也可以是 X:Y 字符串。

注意，当使用固定宽度和高度或者百分比调用 aspect() 时，如果没有调用，则调用将被忽略。

ffmpeg('/path/to/file.avi').size('640x?').aspect('4:3');
ffmpeg('/path/to/file.avi').size('640x?').aspect(1.33333);

autopad ( [color=’black’] ): 启用自动填充输出视频

这里方法允许将自动填充应用到输出视频。 color 参数指定用于 padding的颜色，并且必须是由 ffmpeg ( 默认为’黑色’) 支持的颜色代码或者 NAME。

这里方法的行为取决于对其他视频大小方法所做的调用：

当使用百分比调用 size() 或者还没有调用时，将忽略它；
使用 WxH 调用 size() 时，它添加 padding，以便保留输入纵横比；
当使用 Wx? 或者 ?xH 调用 size() 时，只有在 aspect() 被称为(。否则，输出维度将从输入纵横比计算，而不需要 padding ) 时才添加 padding。

// No size specified, autopad() is ignored
ffmpeg('/path/to/file.avi').autopad();
// Adds padding to keep original aspect ratio.
// - with a 640x400 input, 40 pixels of padding are added on both sides
// - with a 600x480 input, 20 pixels of padding are added on top and bottom
// - with a 320x200 input, video is scaled up to 640x400 and 40px of padding
// is added on both sides
// - with a 320x240 input, video is scaled up to 640x480 and and no padding
// is needed
ffmpeg('/path/to/file.avi').size('640x480').autopad();
ffmpeg('/path/to/file.avi').size('640x480').autopad('white');
ffmpeg('/path/to/file.avi').size('640x480').autopad('#35A5FF');
// Size computed from input, autopad() is ignored
ffmpeg('/path/to/file.avi').size('50%').autopad();
ffmpeg('/path/to/file.avi').size('640x?').autopad();
ffmpeg('/path/to/file.avi').size('?x480').autopad();
// Calling. size('640x?').aspect('4:3') is similar to calling. size('640x480')
// - with a 640x400 input, 40 pixels of padding are added on both sides
// - with a 600x480 input, 20 pixels of padding are added on top and bottom
// - with a 320x200 input, video is scaled up to 640x400 and 40px of padding
// is added on both sides
// - with a 320x240 input, video is scaled up to 640x480 and and no padding
// is needed
ffmpeg('/path/to/file.avi').size('640x?').aspect('4:3').autopad();
ffmpeg('/path/to/file.avi').size('640x?').aspect('4:3').autopad('white');
ffmpeg('/path/to/file.avi').size('640x?').aspect('4:3').autopad('#35A5FF');
// Calling. size('?x480').aspect('4:3') is similar to calling. size('640x480')
ffmpeg('/path/to/file.avi').size('?x480').aspect('4:3').autopad();
ffmpeg('/path/to/file.avi').size('?x480').aspect('4:3').autopad('white');
ffmpeg('/path/to/file.avi').size('?x480').aspect('4:3').autopad('#35A5FF');

为了与前面的fluent-ffmpeg版本兼容，该方法还接受一个附加布尔参数，该参数指定是否应用自动填充。

ffmpeg('/path/to/file.avi').size('640x480').autopad(true);
ffmpeg('/path/to/file.avi').size('640x480').autopad(true, 'pink');

keepDAR(): 力保持显示纵横比

当将非正方形像素转换为不支持非平方像素的输出格式时，这里方法非常有用( 例如。大多数图像格式。它重新调整输入以使显示宽度比相同。

ffmpeg('/path/to/file.avi').keepDAR();

指定多个输出

输出( 目标 [, options] ): 向命令中添加输出

向命令中添加输出。 target 参数可以是输出文件名，也可以是可以写流( 但是至多一个输出流可以与单个命令一起使用)。

当 target 为流时，可能会传递其他 options 对象。如果存在，则将通过ffmpeg输出流 pipe() 方法。

添加输出将切换命令的”当前输出”，所以应用于输出的任何exchangeactivesync方法确实应用于最后添加的输出。为了向后兼容，你还可以在添加第一个输出之前调用这些方法( )。适用于输出的方法都是non-input-related方法，除了 complexFilter() 之外，它是全局的。

还要注意，在调用 output() 时，不应该使用 save() 或者 stream() (。以前 saveToFile() 和 writeToStream() ) 方法，因为它们已经添加了。使用 run() 方法开始处理。

var stream = fs.createWriteStream('outputfile.divx');
ffmpeg('/path/to/file.avi')
    .output('outputfile.mp4')
    .output(stream);
ffmpeg('/path/to/file.avi')
// You may pass a pipe() options object when using a stream. output(stream, { end:true });
// Output-related methods apply to the last output added
ffmpeg('/path/to/file.avi')
    .output('outputfile.mp4')
    .audioCodec('libfaac')
    .videoCodec('libx264')
    .size('320x200')
    .output(stream)
    .preset('divx')
    .size('640x480');
// Use the run() method to run commands with multiple outputs
ffmpeg('/path/to/file.avi')
    .output('outputfile.mp4')
    .output(stream)
    .on('end', function () {
        console.log('Finished processing');
    })
    .run();

输出选项

duration(time): 设置输出持续时间

强制ffmpeg在特定的输出持续时间后停止转码。 time 参数可以是数字( 以秒为单位)，也可以是时间戳字符串( 格式为 [[hh:]mm:]ss[.xxx] )。

ffmpeg('/path/to/file.avi').duration(134.5);
ffmpeg('/path/to/file.avi').duration('2:14.500');

seek(time): 查找输出

在将流编码到输出之前查找流。这与调用 seekInput() 不同，因为偏移量只适用于一个输出。这也会更慢，因为跳过的帧仍将被解码为( 但除去)。

time 参数可以是数字( 以秒为单位)，也可以是时间戳字符串( 格式为 [[hh:]mm:]ss[.xxx] )。

ffmpeg('/path/to/file.avi')
    .seekInput('1:00')
    .output('from-1m30s.avi')
    .seek(30)
    .output('from-1m40s.avi')
    .seek('0:40');

format(format): 设置输出格式

ffmpeg('/path/to/file.avi').format('flv');

flvmeta(): 在转码后更新FLV元数据

调用这里方法可以在输出文件上运行 flvmeta 或者 flvtool2，以添加元数据并制作文件流。输出到流时不起作用，仅在输出为FLV格式时才有用。

ffmpeg('/path/to/file.avi').flvmeta().format('flv');

outputOptions(option…): 添加自定义输出选项

这里方法允许将任何输出相关的选项传递给 ffmpeg。可以使用单个参数调用它，以传递单个选项，也可以使用空格分隔参数：

/* Single option */
ffmpeg('/path/to/file.avi').outputOptions('-someOption');
/* Single option with parameter */
ffmpeg('/dev/video0').outputOptions('-r 24');

你还可以通过将 array 传递给方法来一次传递多个选项：

ffmpeg('/path/to/file.avi').outputOptions([
    '-option1',
    '-option2 param2',
    '-option3',
    '-option4 param4'
]);

最后，你还可以将命令行标记作为单独的参数传递给方法：

ffmpeg('/path/to/file.avi')
    .outputOptions(
        '-option1',
        '-option2', 'param2',
        '-option3',
        '-option4', 'param4'
    );

杂项选项

preset(preset): 使用 fluent-ffmpeg预设

有两种类型的预设支持流畅的ffmpeg。第一个是预设模块；要使用这些模块，请将预设的NAME 作为 preset 参数传递。预设模块从 presets 构造函数选项( 默认为 lib/presets fluent ffmpeg子目录) 指定的目录加载。

// Uses <path-to-fluent-ffmpeg>/lib/presets/divx.js
ffmpeg('/path/to/file.avi').preset('divx');
// Uses/my/presets/foo.js
ffmpeg('/path/to/file.avi', {
    presets: '/my/presets'
}).preset('foo');

预设模块必须导出 load() 函数，该函数接受FfmpegCommand作为参数。流畅的ffmpeg附带了预先设定好的预设模块：

divx
flashvideo
podcast

下面是包含在 divx 预设中的代码示例：

exports.load = function (ffmpeg) {
    ffmpeg
        .format('avi')
        .videoBitrate('1024k')
        .videoCodec('mpeg4')
        .size('720x?')
        .audioBitrate('128k')
        .audioChannels(2)
        .audioCodec('libmp3lame')
        .outputOptions(['-vtag DIVX']);
};

第二种预设是预置函数。使用FfmpegCommand作为参数传递一个函数。

function myPreset(command) {
    command.format('avi').size('720x?');
}
ffmpeg('/path/to/file.avi').preset(myPreset);

complexFilter ( 过滤器 [, map] ): 设置复杂 filtergraph

complexFilter() 方法允许为命令设置复杂的filtergraph。它需要一个过滤器规范( 或者过滤器规格 array ) 和一个可选的输出映射参数作为参数。

过滤规范可以是普通的ffmpeg筛选器字符串( 例如。 split=3[a][b][c] ) 或者具有以下键的对象：

filter: 筛选器名称
options: 可选，可以是过滤器的选项字符串( 例如。 in:0:30 )，用于未命名选项的选项 array ( 例如。 ['in', 0, 30] ) 或者对象映射选项名( 例如。 { t: 'in', s: 0, n: 30 } )。如果未指定 options，将在没有任何选项的情况下添加筛选器。
inputs: 可选，过滤器的输入流说明符。值可以是单个流说明符字符串，也可以是流说明符的array。每个说明符可以选择用方括号括起来。如果没有指定输入流，ffmpeg将使用正确类型的第一个未使用流。
outputs: 可选；过滤器的输出流说明符。值可以是单个流说明符字符串，也可以是流说明符的array。每个说明符可以选择用方括号括起来。

输出映射参数指定要包含在filtergraph的输出中的流。它可以是单个流说明符字符串，也可以是流说明符的array。每个说明符可以选择用方括号括起来。当该参数不存在时，ffmpeg将默认将所有未使用的输出保存到输出文件。

请注意，在给定命令上只能设置一个复杂的filtergraph。再次调用 complexFilter() 将覆盖以前设置的filtergraph，但是你可以在单个调用中设置任意数量的过滤器。

ffmpeg('/path/to/file.avi')
    .complexFilter([
        // Rescale input stream into stream 'rescaled''scale=640:480[rescaled]',
        // Duplicate rescaled stream 3 times into streams a, b, and c 
        {
            filter: 'split',
            options: '3',
            inputs: 'rescaled',
            outputs: ['a', 'b', 'c']
        },
        // Create stream 'red' by removing green and blue channels from stream 'a' 
        {
            filter: 'lutrgb',
            options: {
                g: 0,
                b: 0
            },
            inputs: 'a',
            outputs: 'red'
        },
        // Create stream 'green' by removing red and blue channels from stream 'b' 
        {
            filter: 'lutrgb',
            options: {
                r: 0,
                b: 0
            },
            inputs: 'b',
            outputs: 'green'
        },
        // Create stream 'blue' by removing red and green channels from stream 'c' 
        {
            filter: 'lutrgb',
            options: {
                r: 0,
                g: 0
            },
            inputs: 'c',
            outputs: 'blue'
        },
        // Pad stream 'red' to 3x width, keeping the video on the left,
        // and name output 'padded' 
        {
            filter: 'pad',
            options: {
                w: 'iw*3',
                h: 'ih'
            },
            inputs: 'red',
            outputs: 'padded'
        },
        // Overlay 'green' onto 'padded', moving it to the center,
        // and name output 'redgreen' 
        {
            filter: 'overlay',
            options: {
                x: 'w',
                y: 0
            },
            inputs: ['padded', 'green'],
            outputs: 'redgreen'
        },
        // Overlay 'blue' onto 'redgreen', moving it to the right 
        {
            filter: 'overlay',
            options: {
                x: '2*w',
                y: 0
            },
            inputs: ['redgreen', 'blue'],
            outputs: 'output'
        },
    ], 'output');

设置事件处理程序

在实际运行命令之前，你可能希望设置事件侦听器，以便在完成任务时通知它。以下事件可用：

‘开始’: ffmpeg进程已经启动

ffmpeg('/path/to/file.avi')
    .on('start', function (commandLine) {
        console.log('Spawned Ffmpeg with command: ' + commandLine);
    });

‘codecdata’: 输入编解码器数据

format: 输入格式
duration: 输入持续时间
audio: 音频编解码器
audio_details: 音频编码详细信息
video: 视频编解码器
video_details: 视频编码详细信息

ffmpeg('/path/to/file.avi')
    .on('codecData', function (data) {
        console.log('Input is ' + data.audio + ' audio ' + 'with ' + data.video + ' video');
    });

‘进度’: 转码过程信息

frames: 处理的帧总数
currentFps: FFmpeg当前正在处理的帧数
currentKbps: FFmpeg当前正在处理的吞吐量
targetSize: 目标文件的当前大小以kb为单位
timemark: 当前帧的时间戳秒
percent: 对进度百分比的估计

注意，percent 可以能是( 非常) 不准确的，因为只有进入of的进度信息才是写入( 以及相应的持续时间)的帧数。为了估计百分比，必须猜测总输出持续时间，并使用添加到命令中的第一个输入。特别是：

在使用输入流时，百分比不可用
在使用不同持续时间的多个输入时，百分比可能是错误的，而第一个则不是最长

ffmpeg('/path/to/file.avi')
    .on('progress', function (progress) {
        console.log('Processing: ' + progress.percent + '% done');
    });

‘stderr’: FFmpeg输出

ffmpeg('/path/to/file.avi')
    .on('stderr', function (stderrLine) {
        console.log('Stderr output: ' + stderrLine);
    });

‘错误’: 转码错误

如果流用于输入或者输出，那么这些流发出的任何错误都将通过 error 作为 inputStreamError 和 outputStreamError 分别传递。

向控制台发出警告：如果未发出任何侦听器，则将该错误输出到控制台，并终止程序，从而将 error 事件的处理程序设置为默认的。

ffmpeg('/path/to/file.avi')
    .on('error', function (err, stdout, stderr) {
        console.log('Cannot process video: ' + err.message);
    });

‘结尾’: 处理完成

ffmpeg('/path/to/file.avi')
    .on('end', function (stdout, stderr) {
        console.log('Transcoding succeeded!');
    });

当命令输出到流时，stdout 为空。 stdout 和 stderr 都受 stdoutLines 选项( 默认为 100行)的限制。

FFmpeg处理

save(filename): 将输出保存到文件

启动ffmpeg处理并将输出保存到文件。

ffmpeg('/path/to/file.avi')
    .videoCodec('libx264')
    .audioCodec('libmp3lame')
    .size('320x240')
    .on('error', function (err) {
        console.log('An error occurred: ' + err.message);
    })
    .on('end', function () {
        console.log('Processing finished!');
    })
    .save('/path/to/output.mp4');

注意：save() 方法实际上是用来调用 output() 和 run()的语法糖。

管道( [stream]，[options] ): 将输出输出到可以写流

开始处理和管道ffmpeg输出到可以写流。如果存在 options 参数，则将它的传递给流方法( 请参阅nodejs文档)的ffmpeg输出 pipe()。

var outStream = fs.createWriteStream('/path/to/output.mp4');
ffmpeg('/path/to/file.avi')
    .videoCodec('libx264')
    .audioCodec('libmp3lame')
    .size('320x240')
    .on('error', function (err) {
        console.log('An error occurred: ' + err.message);
    })
    .on('end', function () {
        console.log('Processing finished!');
    })
    .pipe(outStream, {
        end: true
    });

如果没有 stream 参数，pipe() 方法返回一个PassThrough流，你可以将它管道到其他的( 或者只听事件)。

注释: 这只对 node> = 0.10有效。

var command = ffmpeg('/path/to/file.avi')
    .videoCodec('libx264')
    .audioCodec('libmp3lame')
    .size('320x240')
    .on('error', function (err) {
        console.log('An error occurred: ' + err.message);
    })
    .on('end', function () {
        console.log('Processing finished!');
    });
var ffstream = command.pipe();
ffstream.on('data', function (chunk) {
    console.log('ffmpeg just wrote ' + chunk.length + ' bytes');
});

注意：stream() 方法实际上是用来调用 output() 和 run()的语法糖。

run(): 开始处理

这里方法在生成多个输出( 否则，save() 或者 stream() 方法更直接) 时主要有用。它以指定的输出开始处理。

警告: 调用其他处理方法时不要使用 run() ( 例如。 save()，pipe() 或者 screenshots() )。

ffmpeg('/path/to/file.avi')
    .output('screenshot.png')
    .noAudio()
    .seek('3:00')
    .output('small.avi')
    .audioCodec('copy')
    .size('320x200')
    .output('big.avi')
    .audioCodec('copy')
    .size('640x480')
    .on('error', function (err) {
        console.log('An error occurred: ' + err.message);
    })
    .on('end', function () {
        console.log('Processing finished!');
    })
    .run();

mergeToFile ( 文件名，tmpdir ): 连接多个输入

ffmpeg('/path/to/part1.avi')
    .input('/path/to/part2.avi')
    .input('/path/to/part2.avi')
    .on('error', function (err) {
        console.log('An error occurred: ' + err.message);
    })
    .on('end', function () {
        console.log('Merging finished!');
    })
    .mergeToFile('/path/to/merged.avi', '/path/to/tempDir');

屏幕截图( 选项 [, dirname] ): 生成缩略图

使用 screenshots 方法提取一个或者多个缩略图，并将它们保存为PNG文件。但是，对于这里实现，有一些注意事项：

它在输入流上不起作用。
progress 事件报告的进度信息不准确。
它的过滤效果不好。特别是，不要使用 size() 方法调整缩略图大小，而使用 size 选项。

options 参数是具有以下键的对象：

folder: 生成的图像文件的输出文件夹。默认为当前文件夹。
filename: 输出文件名 Pattern ( 请参见下面)。默认为” tn.png”。
count: 指定要生成的缩略图数。使用这里选项时，将在视频( 例如当请求 3个缩略图时，在 25%。50%和视频长度的75% ) 中定期生成缩略图。指定 timemarks 或者 timestamps 时，count 被忽略。
timemarks 或者 timestamps: 指定视频中的时间戳的array，缩略图应在其中执行。每个时间戳可以是一个数字( 以秒为单位)，一个百分比字符串( 例如。 “50%”) 或者时间戳字符串，格式为”。hh: mm: ss”( 时间。分钟和毫秒都可选)。
size: 指定缩略图( 使用与 .size() 方法相同的格式)的目标大小。注意：在生成缩略图时不应该使用 .size()方法。

filename 选项为生成的文件指定文件名 Pattern。它可能包含以下格式标记：

‘%s’: 在秒内偏移
‘%w’: 屏幕截图宽度
‘%h’: 屏幕截图高度
‘%r’: 屏幕截图分辨率( 同’%wx%h )
‘%f’: 输入文件名
‘%b’: 输入 basename ( 文件名为w/o 扩展)
“%i”：timemark array 截图索引( 可以通过使用 %000i 来填充)

如果在文件名 Pattern 中指定了多个 timemarks，并且没有变量格式标记(‘%s’或者或或者’%i’)，那么将自动添加 _%i。

生成缩略图时，将使用生成文件名的array 作为参数分派一个附加的filenames 事件。

ffmpeg('/path/to/video.avi')
    .on('filenames', function (filenames) {
        console.log('Will generate ' + filenames.join(', '))
    })
    .on('end', function () {
        console.log('Screenshots taken');
    })
    .screenshots({
        // Will take screens at 20%, 40%, 60% and 80% of the video count:4,
        folder: '/path/to/output'
    });
ffmpeg('/path/to/video.avi')
    .screenshots({
        timestamps: [30.5, '50%', '01:10.123'],
        filename: 'thumbnail-at-%s-seconds.png',
        folder: '/path/to/output',
        size: '320x240'
    });

控制FFmpeg进程

终止( [signal=’SIGKILL’] ): 杀死任何正在运行的ffmpeg进程

var command = ffmpeg('/path/to/video.avi')
    .videoCodec('libx264')
    .audioCodec('libmp3lame')
    .on('start', function () {
        // Send SIGSTOP to suspend ffmpegcommand.kill('SIGSTOP');
        doSomething(function () {
            // Send SIGCONT to resume ffmpegcommand.kill('SIGCONT');
        });
    })
    .save('/path/to/output.mp4');
// Kill ffmpeg after 60 seconds anywaysetTimeout
(function () {
    command.on('error', function () {
        console.log('Ffmpeg has been killed');
    });
    command.kill();
}, 60000);

renice ( [niceness=0] ): 更改ffmpeg进程优先级

注释：在 Windows 平台上这个方法无效。

// Set startup niceness
var command = ffmpeg('/path/to/file.avi')
    .renice(5)
    .save('/path/to/output.mp4');
// Command takes too long, raise its prioritysetTimeout
(function () {
    command.renice(-5);
}, 60000);

读取视频元数据

你可以使用模块 ffprobe 方法从任何有效的ffmpeg输入文件中读取元数据。

ffmpeg.ffprobe('/path/to/file.avi', function (err, metadata) {
    console.dir(metadata);
});

你也可以在FfmpegCommand上调用ffprobe方法来探测它的一个输入。可以将 0-based 输入号作为第一个参数来指定从中读取元数据的输入，否则将探测上次添加的输入。

ffmpeg('/path/to/file1.avi')
    .input('/path/to/file2.avi')
    .ffprobe(function (err, data) {
        console.log('file2 metadata:');
        console.dir(data);
    });
ffmpeg('/path/to/file1.avi')
    .input('/path/to/file2.avi')
    .ffprobe(0, function (err, data) {
        console.log('file1 metadata:');
        console.dir(data);
    });

警告：可能使用输入流调用，但是在这种情况下，它将消耗来自流的数据，并且该数据将不再可用。如果在相同的输入流上使用ffprobe和转码命令很可能会失败，除非流是流流。只有当你知道自己在做什么的时候才这么做。

返回的对象与在 shell ( 根据你的ffmpeg版本，你可能必须用 -print_format 替换 -of ) 中运行以下命令返回的对象相同：

$ ffprobe -of json -show_streams -show_format/path/to/file.avi

它将包含有关容器( 作为 format 键) 和流( 作为 stream 键)的array的信息。 format对象和每个流对象也包含元数据标记，具体取决于格式：

{
    "streams": [{
            "index": 0,
            "codec_name": "h264",
            "codec_long_name": "H.264/AVC/MPEG-4 AVC/MPEG-4 part 10",
            "profile": "Constrained Baseline",
            "codec_type": "video",
            "codec_time_base": "1/48",
            "codec_tag_string": "avc1",
            "codec_tag": "0x31637661",
            "width": 320,
            "height": 180,
            "has_b_frames": 0,
            "sample_aspect_ratio": "1:1",
            "display_aspect_ratio": "16:9",
            "pix_fmt": "yuv420p",
            "level": 13,
            "r_frame_rate": "24/1",
            "avg_frame_rate": "24/1",
            "time_base": "1/24",
            "start_pts": 0,
            "start_time": "0.000000",
            "duration_ts": 14315,
            "duration": "596.458333",
            "bit_rate": "702655",
            "nb_frames": "14315",
            "disposition": {
                "default": 0,
                "dub": 0,
                "original": 0,
                "comment": 0,
                "lyrics": 0,
                "karaoke": 0,
                "forced": 0,
                "hearing_impaired": 0,
                "visual_impaired": 0,
                "clean_effects": 0,
                "attached_pic": 0
            },
            "tags": {
                "creation_time": "1970-01-01 00:00:00",
                "language": "und",
                "handler_name": "fVideoHandler"
            }
        },
        {
            "index": 1,
            "codec_name": "aac",
            "codec_long_name": "AAC (Advanced Audio Coding)",
            "codec_type": "audio",
            "codec_time_base": "1/48000",
            "codec_tag_string": "mp4a",
            "codec_tag": "0x6134706d",
            "sample_fmt": "fltp",
            "sample_rate": "48000",
            "channels": 2,
            "bits_per_sample": 0,
            "r_frame_rate": "0/0",
            "avg_frame_rate": "0/0",
            "time_base": "1/48000",
            "start_pts": 0,
            "start_time": "0.000000",
            "duration_ts": 28619776,
            "duration": "596.245333",
            "bit_rate": "159997",
            "nb_frames": "27949",
            "disposition": {
                "default": 0,
                "dub": 0,
                "original": 0,
                "comment": 0,
                "lyrics": 0,
                "karaoke": 0,
                "forced": 0,
                "hearing_impaired": 0,
                "visual_impaired": 0,
                "clean_effects": 0,
                "attached_pic": 0
            },
            "tags": {
                "creation_time": "1970-01-01 00:00:00",
                "language": "und",
                "handler_name": "fSoundHandler"
            }
        }
    ],
    "format": {
        "filename": "http://download.blender.org/peach/bigbuckbunny_movies/BigBuckBunny_320x180.mp4",
        "nb_streams": 2,
        "format_name": "mov,mp4,m4a,3gp,3g2,mj2",
        "format_long_name": "QuickTime/MOV",
        "start_time": "0.000000",
        "duration": "596.459000",
        "size": "64657027",
        "bit_rate": "867211",
        "tags": {
            "major_brand": "isom",
            "minor_version": "512",
            "compatible_brands": "mp41",
            "creation_time": "1970-01-01 00:00:00",
            "title": "Big Buck Bunny",
            "artist": "Blender Foundation",
            "composer": "Blender Foundation",
            "date": "2008",
            "encoder": "Lavf52.14.0"
        }
    }
}

查询ffmpeg功能

流畅的ffmpeg允许你查询已经安装的ffmpeg版本以获得支持的格式。编解码器。编码器和过滤器。

var Ffmpeg = require('fluent-ffmpeg');
Ffmpeg.getAvailableFormats(function (err, formats) {
    console.log('Available formats:');
    console.dir(formats);
});
Ffmpeg.getAvailableCodecs(function (err, codecs) {
    console.log('Available codecs:');
    console.dir(codecs);
});
Ffmpeg.getAvailableEncoders(function (err, encoders) {
    console.log('Available encoders:');
    console.dir(encoders);
});
Ffmpeg.getAvailableFilters(function (err, filters) {
    console.log("Available filters:");
    console.dir(filters);
});
// Those methods can also be called on commands
new Ffmpeg({
        source: '/path/to/file.avi'
    })
    .getAvailableCodecs(...);

这些方法将对象传递给它的回调，其中包含每个可用格式。编解码器或者筛选器的键。

返回的格式的返回对象看起来像：

{
    // ...
    mp4: {
        description: 'MP4 (MPEG-4 Part 14)',
        canDemux: false,
        canMux: true
    },
    //...
}

canDemux 指示ffmpeg是否能够从( demux ) 提取流
canMux 表示ffmpeg是否能够将流写入( mux )

编解码器的返回对象看起来像：

{
 ... mp3: {
 type:'audio',
 description:'MP3 (MPEG audio layer 3)',
 canDecode:true,
 canEncode:true,
 intraFrameOnly:false,
 isLossy:true,
 isLossless:false },
 ...}

type 表示编解码器类型，”音频”，”视频”或者 subtitle”
canDecode 告诉ffmpeg是否能够使用这个编解码器解码流
canEncode 告诉ffmpeg是否能够使用这个编解码器编码流

根据你的ffmpeg版本( 或者如果你使用 avconv ) 其他键可能存在，例如：

directRendering 告诉编解码器是否可以直接在 GPU RAM中呈现；用于转换的用途无用
intraFrameOnly 告诉编解码器编解码器是否只能与i 帧一起工作
isLossy 告诉编解码器是否可以进行有损编码/解码
isLossless 告诉编解码器是否可以进行无损编码/解码

有一些 tftp/avcodec版本，描述包括编码器/解码器，提到了”foo编解码器( 解码器)”： libdecodefoo ) ( 编码器：libencodefoo )”。在这种情况下，你将希望使用这些编码器/解码器代替( 由 getAvailableCodecs 返回的编解码器对象也将包括它们)。

编码器返回的对象看起来像：

{
 ... libmp3lame: {
 type:'audio',
 description:'MP3 (MPEG audio layer 3) (codec mp3)',
 frameMT:false,
 sliceMT:false,
 experimental:false,
 drawHorizBand:false,
 directRendering:false },
 ...}

type 表示编码器类型，”音频”，”视频”或者 subtitle”
experimental 表示编码器是否处于实验状态。使用这样的编解码器时，fluent会自动添加’-strict实验’标志。

过滤器返回的对象看起来像：

{
    // ...
    scale: {
        description: 'Scale the input video to width:height size and/or convert the image format.',
        input: 'video',
        multipleInputs: false,
        output: 'video',
        multipleOutputs: false
    },
    // ...
}

input 告诉输入类型这个过滤器操作，”音频”，”视频”或者”无”。当”无”时，筛选器可能会生成无输出的输出
multipleInputs 指示筛选器是否可以接受多个输入
output 告知输出类型这里筛选器生成的”音频”。”视频”或者”无”。当”无”时，筛选器没有输出( 只接收接收器)
multipleInputs 指示筛选器是否可以生成多个输出

克隆实例

你可以通过调用 clone() 方法来创建FfmpegCommand实例的克隆。克隆将是原始的原始副本，当它被称为( 相同的输入，相同的选项，相同的事件处理程序，等等 ) 时。当你希望在同一输入上应用不同的处理选项时，这主要是有用的。

设置选项，在克隆上添加输入或者事件处理程序将不会影响原始命令。

// Create a command to convert source.avi to MP4
var command = ffmpeg('/path/to/source.avi')
    .audioCodec('libfaac')
    .videoCodec('libx264')
    .format('mp4');
// Create a clone to save a small resized version
command.clone()
    .size('320x200')
    .save('/path/to/output-small.mp4');
// Create a clone to save a medium resized version
command.clone()
    .size('640x400')
    .save('/path/to/output-medium.mp4');
// Save a converted version with the original size
command.save('/path/to/output-original-size.mp4');