|
<!DOCTYPE html> |
|
<html lang="en"> |
|
<head> |
|
<meta charset="utf-8"> |
|
<title>JSDoc: Source: capabilities.js</title> |
|
|
|
<script src="scripts/prettify/prettify.js"> </script> |
|
<script src="scripts/prettify/lang-css.js"> </script> |
|
|
|
|
|
|
|
<link type="text/css" rel="stylesheet" href="styles/prettify-tomorrow.css"> |
|
<link type="text/css" rel="stylesheet" href="styles/jsdoc-default.css"> |
|
</head> |
|
|
|
<body> |
|
|
|
<div id="main"> |
|
|
|
<h1 class="page-title">Source: capabilities.js</h1> |
|
|
|
|
|
|
|
|
|
|
|
<section> |
|
<article> |
|
<pre class="prettyprint source linenums"><code>/*jshint node:true*/ |
|
'use strict'; |
|
|
|
var fs = require('fs'); |
|
var path = require('path'); |
|
var async = require('async'); |
|
var utils = require('./utils'); |
|
|
|
/* |
|
*! Capability helpers |
|
*/ |
|
|
|
var avCodecRegexp = /^\s*([D ])([E ])([VAS])([S ])([D ])([T ]) ([^ ]+) +(.*)$/; |
|
var ffCodecRegexp = /^\s*([D\.])([E\.])([VAS])([I\.])([L\.])([S\.]) ([^ ]+) +(.*)$/; |
|
var ffEncodersRegexp = /\(encoders:([^\)]+)\)/; |
|
var ffDecodersRegexp = /\(decoders:([^\)]+)\)/; |
|
var encodersRegexp = /^\s*([VAS\.])([F\.])([S\.])([X\.])([B\.])([D\.]) ([^ ]+) +(.*)$/; |
|
var formatRegexp = /^\s*([D ])([E ])\s+([^ ]+)\s+(.*)$/; |
|
var lineBreakRegexp = /\r\n|\r|\n/; |
|
var filterRegexp = /^(?: [T\.][S\.][C\.] )?([^ ]+) +(AA?|VV?|\|)->(AA?|VV?|\|) +(.*)$/; |
|
|
|
var cache = {}; |
|
|
|
module.exports = function(proto) { |
|
/** |
|
* Manually define the ffmpeg binary full path. |
|
* |
|
* @method FfmpegCommand#setFfmpegPath |
|
* |
|
* @param {String} ffmpegPath The full path to the ffmpeg binary. |
|
* @return FfmpegCommand |
|
*/ |
|
proto.setFfmpegPath = function(ffmpegPath) { |
|
cache.ffmpegPath = ffmpegPath; |
|
return this; |
|
}; |
|
|
|
/** |
|
* Manually define the ffprobe binary full path. |
|
* |
|
* @method FfmpegCommand#setFfprobePath |
|
* |
|
* @param {String} ffprobePath The full path to the ffprobe binary. |
|
* @return FfmpegCommand |
|
*/ |
|
proto.setFfprobePath = function(ffprobePath) { |
|
cache.ffprobePath = ffprobePath; |
|
return this; |
|
}; |
|
|
|
/** |
|
* Manually define the flvtool2/flvmeta binary full path. |
|
* |
|
* @method FfmpegCommand#setFlvtoolPath |
|
* |
|
* @param {String} flvtool The full path to the flvtool2 or flvmeta binary. |
|
* @return FfmpegCommand |
|
*/ |
|
proto.setFlvtoolPath = function(flvtool) { |
|
cache.flvtoolPath = flvtool; |
|
return this; |
|
}; |
|
|
|
/** |
|
* Forget executable paths |
|
* |
|
* (only used for testing purposes) |
|
* |
|
* @method FfmpegCommand#_forgetPaths |
|
* @private |
|
*/ |
|
proto._forgetPaths = function() { |
|
delete cache.ffmpegPath; |
|
delete cache.ffprobePath; |
|
delete cache.flvtoolPath; |
|
}; |
|
|
|
/** |
|
* Check for ffmpeg availability |
|
* |
|
* If the FFMPEG_PATH environment variable is set, try to use it. |
|
* If it is unset or incorrect, try to find ffmpeg in the PATH instead. |
|
* |
|
* @method FfmpegCommand#_getFfmpegPath |
|
* @param {Function} callback callback with signature (err, path) |
|
* @private |
|
*/ |
|
proto._getFfmpegPath = function(callback) { |
|
if ('ffmpegPath' in cache) { |
|
return callback(null, cache.ffmpegPath); |
|
} |
|
|
|
async.waterfall([ |
|
// Try FFMPEG_PATH |
|
function(cb) { |
|
if (process.env.FFMPEG_PATH) { |
|
fs.exists(process.env.FFMPEG_PATH, function(exists) { |
|
if (exists) { |
|
cb(null, process.env.FFMPEG_PATH); |
|
} else { |
|
cb(null, ''); |
|
} |
|
}); |
|
} else { |
|
cb(null, ''); |
|
} |
|
}, |
|
|
|
// Search in the PATH |
|
function(ffmpeg, cb) { |
|
if (ffmpeg.length) { |
|
return cb(null, ffmpeg); |
|
} |
|
|
|
utils.which('ffmpeg', function(err, ffmpeg) { |
|
cb(err, ffmpeg); |
|
}); |
|
} |
|
], function(err, ffmpeg) { |
|
if (err) { |
|
callback(err); |
|
} else { |
|
callback(null, cache.ffmpegPath = (ffmpeg || '')); |
|
} |
|
}); |
|
}; |
|
|
|
|
|
/** |
|
* Check for ffprobe availability |
|
* |
|
* If the FFPROBE_PATH environment variable is set, try to use it. |
|
* If it is unset or incorrect, try to find ffprobe in the PATH instead. |
|
* If this still fails, try to find ffprobe in the same directory as ffmpeg. |
|
* |
|
* @method FfmpegCommand#_getFfprobePath |
|
* @param {Function} callback callback with signature (err, path) |
|
* @private |
|
*/ |
|
proto._getFfprobePath = function(callback) { |
|
var self = this; |
|
|
|
if ('ffprobePath' in cache) { |
|
return callback(null, cache.ffprobePath); |
|
} |
|
|
|
async.waterfall([ |
|
// Try FFPROBE_PATH |
|
function(cb) { |
|
if (process.env.FFPROBE_PATH) { |
|
fs.exists(process.env.FFPROBE_PATH, function(exists) { |
|
cb(null, exists ? process.env.FFPROBE_PATH : ''); |
|
}); |
|
} else { |
|
cb(null, ''); |
|
} |
|
}, |
|
|
|
// Search in the PATH |
|
function(ffprobe, cb) { |
|
if (ffprobe.length) { |
|
return cb(null, ffprobe); |
|
} |
|
|
|
utils.which('ffprobe', function(err, ffprobe) { |
|
cb(err, ffprobe); |
|
}); |
|
}, |
|
|
|
// Search in the same directory as ffmpeg |
|
function(ffprobe, cb) { |
|
if (ffprobe.length) { |
|
return cb(null, ffprobe); |
|
} |
|
|
|
self._getFfmpegPath(function(err, ffmpeg) { |
|
if (err) { |
|
cb(err); |
|
} else if (ffmpeg.length) { |
|
var name = utils.isWindows ? 'ffprobe.exe' : 'ffprobe'; |
|
var ffprobe = path.join(path.dirname(ffmpeg), name); |
|
fs.exists(ffprobe, function(exists) { |
|
cb(null, exists ? ffprobe : ''); |
|
}); |
|
} else { |
|
cb(null, ''); |
|
} |
|
}); |
|
} |
|
], function(err, ffprobe) { |
|
if (err) { |
|
callback(err); |
|
} else { |
|
callback(null, cache.ffprobePath = (ffprobe || '')); |
|
} |
|
}); |
|
}; |
|
|
|
|
|
/** |
|
* Check for flvtool2/flvmeta availability |
|
* |
|
* If the FLVTOOL2_PATH or FLVMETA_PATH environment variable are set, try to use them. |
|
* If both are either unset or incorrect, try to find flvtool2 or flvmeta in the PATH instead. |
|
* |
|
* @method FfmpegCommand#_getFlvtoolPath |
|
* @param {Function} callback callback with signature (err, path) |
|
* @private |
|
*/ |
|
proto._getFlvtoolPath = function(callback) { |
|
if ('flvtoolPath' in cache) { |
|
return callback(null, cache.flvtoolPath); |
|
} |
|
|
|
async.waterfall([ |
|
// Try FLVMETA_PATH |
|
function(cb) { |
|
if (process.env.FLVMETA_PATH) { |
|
fs.exists(process.env.FLVMETA_PATH, function(exists) { |
|
cb(null, exists ? process.env.FLVMETA_PATH : ''); |
|
}); |
|
} else { |
|
cb(null, ''); |
|
} |
|
}, |
|
|
|
// Try FLVTOOL2_PATH |
|
function(flvtool, cb) { |
|
if (flvtool.length) { |
|
return cb(null, flvtool); |
|
} |
|
|
|
if (process.env.FLVTOOL2_PATH) { |
|
fs.exists(process.env.FLVTOOL2_PATH, function(exists) { |
|
cb(null, exists ? process.env.FLVTOOL2_PATH : ''); |
|
}); |
|
} else { |
|
cb(null, ''); |
|
} |
|
}, |
|
|
|
// Search for flvmeta in the PATH |
|
function(flvtool, cb) { |
|
if (flvtool.length) { |
|
return cb(null, flvtool); |
|
} |
|
|
|
utils.which('flvmeta', function(err, flvmeta) { |
|
cb(err, flvmeta); |
|
}); |
|
}, |
|
|
|
// Search for flvtool2 in the PATH |
|
function(flvtool, cb) { |
|
if (flvtool.length) { |
|
return cb(null, flvtool); |
|
} |
|
|
|
utils.which('flvtool2', function(err, flvtool2) { |
|
cb(err, flvtool2); |
|
}); |
|
}, |
|
], function(err, flvtool) { |
|
if (err) { |
|
callback(err); |
|
} else { |
|
callback(null, cache.flvtoolPath = (flvtool || '')); |
|
} |
|
}); |
|
}; |
|
|
|
|
|
/** |
|
* A callback passed to {@link FfmpegCommand#availableFilters}. |
|
* |
|
* @callback FfmpegCommand~filterCallback |
|
* @param {Error|null} err error object or null if no error happened |
|
* @param {Object} filters filter object with filter names as keys and the following |
|
* properties for each filter: |
|
* @param {String} filters.description filter description |
|
* @param {String} filters.input input type, one of 'audio', 'video' and 'none' |
|
* @param {Boolean} filters.multipleInputs whether the filter supports multiple inputs |
|
* @param {String} filters.output output type, one of 'audio', 'video' and 'none' |
|
* @param {Boolean} filters.multipleOutputs whether the filter supports multiple outputs |
|
*/ |
|
|
|
/** |
|
* Query ffmpeg for available filters |
|
* |
|
* @method FfmpegCommand#availableFilters |
|
* @category Capabilities |
|
* @aliases getAvailableFilters |
|
* |
|
* @param {FfmpegCommand~filterCallback} callback callback function |
|
*/ |
|
proto.availableFilters = |
|
proto.getAvailableFilters = function(callback) { |
|
if ('filters' in cache) { |
|
return callback(null, cache.filters); |
|
} |
|
|
|
this._spawnFfmpeg(['-filters'], { captureStdout: true, stdoutLines: 0 }, function (err, stdoutRing) { |
|
if (err) { |
|
return callback(err); |
|
} |
|
|
|
var stdout = stdoutRing.get(); |
|
var lines = stdout.split('\n'); |
|
var data = {}; |
|
var types = { A: 'audio', V: 'video', '|': 'none' }; |
|
|
|
lines.forEach(function(line) { |
|
var match = line.match(filterRegexp); |
|
if (match) { |
|
data[match[1]] = { |
|
description: match[4], |
|
input: types[match[2].charAt(0)], |
|
multipleInputs: match[2].length > 1, |
|
output: types[match[3].charAt(0)], |
|
multipleOutputs: match[3].length > 1 |
|
}; |
|
} |
|
}); |
|
|
|
callback(null, cache.filters = data); |
|
}); |
|
}; |
|
|
|
|
|
/** |
|
* A callback passed to {@link FfmpegCommand#availableCodecs}. |
|
* |
|
* @callback FfmpegCommand~codecCallback |
|
* @param {Error|null} err error object or null if no error happened |
|
* @param {Object} codecs codec object with codec names as keys and the following |
|
* properties for each codec (more properties may be available depending on the |
|
* ffmpeg version used): |
|
* @param {String} codecs.description codec description |
|
* @param {Boolean} codecs.canDecode whether the codec is able to decode streams |
|
* @param {Boolean} codecs.canEncode whether the codec is able to encode streams |
|
*/ |
|
|
|
/** |
|
* Query ffmpeg for available codecs |
|
* |
|
* @method FfmpegCommand#availableCodecs |
|
* @category Capabilities |
|
* @aliases getAvailableCodecs |
|
* |
|
* @param {FfmpegCommand~codecCallback} callback callback function |
|
*/ |
|
proto.availableCodecs = |
|
proto.getAvailableCodecs = function(callback) { |
|
if ('codecs' in cache) { |
|
return callback(null, cache.codecs); |
|
} |
|
|
|
this._spawnFfmpeg(['-codecs'], { captureStdout: true, stdoutLines: 0 }, function(err, stdoutRing) { |
|
if (err) { |
|
return callback(err); |
|
} |
|
|
|
var stdout = stdoutRing.get(); |
|
var lines = stdout.split(lineBreakRegexp); |
|
var data = {}; |
|
|
|
lines.forEach(function(line) { |
|
var match = line.match(avCodecRegexp); |
|
if (match && match[7] !== '=') { |
|
data[match[7]] = { |
|
type: { 'V': 'video', 'A': 'audio', 'S': 'subtitle' }[match[3]], |
|
description: match[8], |
|
canDecode: match[1] === 'D', |
|
canEncode: match[2] === 'E', |
|
drawHorizBand: match[4] === 'S', |
|
directRendering: match[5] === 'D', |
|
weirdFrameTruncation: match[6] === 'T' |
|
}; |
|
} |
|
|
|
match = line.match(ffCodecRegexp); |
|
if (match && match[7] !== '=') { |
|
var codecData = data[match[7]] = { |
|
type: { 'V': 'video', 'A': 'audio', 'S': 'subtitle' }[match[3]], |
|
description: match[8], |
|
canDecode: match[1] === 'D', |
|
canEncode: match[2] === 'E', |
|
intraFrameOnly: match[4] === 'I', |
|
isLossy: match[5] === 'L', |
|
isLossless: match[6] === 'S' |
|
}; |
|
|
|
var encoders = codecData.description.match(ffEncodersRegexp); |
|
encoders = encoders ? encoders[1].trim().split(' ') : []; |
|
|
|
var decoders = codecData.description.match(ffDecodersRegexp); |
|
decoders = decoders ? decoders[1].trim().split(' ') : []; |
|
|
|
if (encoders.length || decoders.length) { |
|
var coderData = {}; |
|
utils.copy(codecData, coderData); |
|
delete coderData.canEncode; |
|
delete coderData.canDecode; |
|
|
|
encoders.forEach(function(name) { |
|
data[name] = {}; |
|
utils.copy(coderData, data[name]); |
|
data[name].canEncode = true; |
|
}); |
|
|
|
decoders.forEach(function(name) { |
|
if (name in data) { |
|
data[name].canDecode = true; |
|
} else { |
|
data[name] = {}; |
|
utils.copy(coderData, data[name]); |
|
data[name].canDecode = true; |
|
} |
|
}); |
|
} |
|
} |
|
}); |
|
|
|
callback(null, cache.codecs = data); |
|
}); |
|
}; |
|
|
|
|
|
/** |
|
* A callback passed to {@link FfmpegCommand#availableEncoders}. |
|
* |
|
* @callback FfmpegCommand~encodersCallback |
|
* @param {Error|null} err error object or null if no error happened |
|
* @param {Object} encoders encoders object with encoder names as keys and the following |
|
* properties for each encoder: |
|
* @param {String} encoders.description codec description |
|
* @param {Boolean} encoders.type "audio", "video" or "subtitle" |
|
* @param {Boolean} encoders.frameMT whether the encoder is able to do frame-level multithreading |
|
* @param {Boolean} encoders.sliceMT whether the encoder is able to do slice-level multithreading |
|
* @param {Boolean} encoders.experimental whether the encoder is experimental |
|
* @param {Boolean} encoders.drawHorizBand whether the encoder supports draw_horiz_band |
|
* @param {Boolean} encoders.directRendering whether the encoder supports direct encoding method 1 |
|
*/ |
|
|
|
/** |
|
* Query ffmpeg for available encoders |
|
* |
|
* @method FfmpegCommand#availableEncoders |
|
* @category Capabilities |
|
* @aliases getAvailableEncoders |
|
* |
|
* @param {FfmpegCommand~encodersCallback} callback callback function |
|
*/ |
|
proto.availableEncoders = |
|
proto.getAvailableEncoders = function(callback) { |
|
if ('encoders' in cache) { |
|
return callback(null, cache.encoders); |
|
} |
|
|
|
this._spawnFfmpeg(['-encoders'], { captureStdout: true, stdoutLines: 0 }, function(err, stdoutRing) { |
|
if (err) { |
|
return callback(err); |
|
} |
|
|
|
var stdout = stdoutRing.get(); |
|
var lines = stdout.split(lineBreakRegexp); |
|
var data = {}; |
|
|
|
lines.forEach(function(line) { |
|
var match = line.match(encodersRegexp); |
|
if (match && match[7] !== '=') { |
|
data[match[7]] = { |
|
type: { 'V': 'video', 'A': 'audio', 'S': 'subtitle' }[match[1]], |
|
description: match[8], |
|
frameMT: match[2] === 'F', |
|
sliceMT: match[3] === 'S', |
|
experimental: match[4] === 'X', |
|
drawHorizBand: match[5] === 'B', |
|
directRendering: match[6] === 'D' |
|
}; |
|
} |
|
}); |
|
|
|
callback(null, cache.encoders = data); |
|
}); |
|
}; |
|
|
|
|
|
/** |
|
* A callback passed to {@link FfmpegCommand#availableFormats}. |
|
* |
|
* @callback FfmpegCommand~formatCallback |
|
* @param {Error|null} err error object or null if no error happened |
|
* @param {Object} formats format object with format names as keys and the following |
|
* properties for each format: |
|
* @param {String} formats.description format description |
|
* @param {Boolean} formats.canDemux whether the format is able to demux streams from an input file |
|
* @param {Boolean} formats.canMux whether the format is able to mux streams into an output file |
|
*/ |
|
|
|
/** |
|
* Query ffmpeg for available formats |
|
* |
|
* @method FfmpegCommand#availableFormats |
|
* @category Capabilities |
|
* @aliases getAvailableFormats |
|
* |
|
* @param {FfmpegCommand~formatCallback} callback callback function |
|
*/ |
|
proto.availableFormats = |
|
proto.getAvailableFormats = function(callback) { |
|
if ('formats' in cache) { |
|
return callback(null, cache.formats); |
|
} |
|
|
|
// Run ffmpeg -formats |
|
this._spawnFfmpeg(['-formats'], { captureStdout: true, stdoutLines: 0 }, function (err, stdoutRing) { |
|
if (err) { |
|
return callback(err); |
|
} |
|
|
|
// Parse output |
|
var stdout = stdoutRing.get(); |
|
var lines = stdout.split(lineBreakRegexp); |
|
var data = {}; |
|
|
|
lines.forEach(function(line) { |
|
var match = line.match(formatRegexp); |
|
if (match) { |
|
match[3].split(',').forEach(function(format) { |
|
if (!(format in data)) { |
|
data[format] = { |
|
description: match[4], |
|
canDemux: false, |
|
canMux: false |
|
}; |
|
} |
|
|
|
if (match[1] === 'D') { |
|
data[format].canDemux = true; |
|
} |
|
if (match[2] === 'E') { |
|
data[format].canMux = true; |
|
} |
|
}); |
|
} |
|
}); |
|
|
|
callback(null, cache.formats = data); |
|
}); |
|
}; |
|
|
|
|
|
/** |
|
* Check capabilities before executing a command |
|
* |
|
* Checks whether all used codecs and formats are indeed available |
|
* |
|
* @method FfmpegCommand#_checkCapabilities |
|
* @param {Function} callback callback with signature (err) |
|
* @private |
|
*/ |
|
proto._checkCapabilities = function(callback) { |
|
var self = this; |
|
async.waterfall([ |
|
// Get available formats |
|
function(cb) { |
|
self.availableFormats(cb); |
|
}, |
|
|
|
// Check whether specified formats are available |
|
function(formats, cb) { |
|
var unavailable; |
|
|
|
// Output format(s) |
|
unavailable = self._outputs |
|
.reduce(function(fmts, output) { |
|
var format = output.options.find('-f', 1); |
|
if (format) { |
|
if (!(format[0] in formats) || !(formats[format[0]].canMux)) { |
|
fmts.push(format); |
|
} |
|
} |
|
|
|
return fmts; |
|
}, []); |
|
|
|
if (unavailable.length === 1) { |
|
return cb(new Error('Output format ' + unavailable[0] + ' is not available')); |
|
} else if (unavailable.length > 1) { |
|
return cb(new Error('Output formats ' + unavailable.join(', ') + ' are not available')); |
|
} |
|
|
|
// Input format(s) |
|
unavailable = self._inputs |
|
.reduce(function(fmts, input) { |
|
var format = input.options.find('-f', 1); |
|
if (format) { |
|
if (!(format[0] in formats) || !(formats[format[0]].canDemux)) { |
|
fmts.push(format[0]); |
|
} |
|
} |
|
|
|
return fmts; |
|
}, []); |
|
|
|
if (unavailable.length === 1) { |
|
return cb(new Error('Input format ' + unavailable[0] + ' is not available')); |
|
} else if (unavailable.length > 1) { |
|
return cb(new Error('Input formats ' + unavailable.join(', ') + ' are not available')); |
|
} |
|
|
|
cb(); |
|
}, |
|
|
|
// Get available codecs |
|
function(cb) { |
|
self.availableEncoders(cb); |
|
}, |
|
|
|
// Check whether specified codecs are available and add strict experimental options if needed |
|
function(encoders, cb) { |
|
var unavailable; |
|
|
|
// Audio codec(s) |
|
unavailable = self._outputs.reduce(function(cdcs, output) { |
|
var acodec = output.audio.find('-acodec', 1); |
|
if (acodec && acodec[0] !== 'copy') { |
|
if (!(acodec[0] in encoders) || encoders[acodec[0]].type !== 'audio') { |
|
cdcs.push(acodec[0]); |
|
} |
|
} |
|
|
|
return cdcs; |
|
}, []); |
|
|
|
if (unavailable.length === 1) { |
|
return cb(new Error('Audio codec ' + unavailable[0] + ' is not available')); |
|
} else if (unavailable.length > 1) { |
|
return cb(new Error('Audio codecs ' + unavailable.join(', ') + ' are not available')); |
|
} |
|
|
|
// Video codec(s) |
|
unavailable = self._outputs.reduce(function(cdcs, output) { |
|
var vcodec = output.video.find('-vcodec', 1); |
|
if (vcodec && vcodec[0] !== 'copy') { |
|
if (!(vcodec[0] in encoders) || encoders[vcodec[0]].type !== 'video') { |
|
cdcs.push(vcodec[0]); |
|
} |
|
} |
|
|
|
return cdcs; |
|
}, []); |
|
|
|
if (unavailable.length === 1) { |
|
return cb(new Error('Video codec ' + unavailable[0] + ' is not available')); |
|
} else if (unavailable.length > 1) { |
|
return cb(new Error('Video codecs ' + unavailable.join(', ') + ' are not available')); |
|
} |
|
|
|
cb(); |
|
} |
|
], callback); |
|
}; |
|
}; |
|
</code></pre> |
|
</article> |
|
</section> |
|
|
|
|
|
|
|
|
|
</div> |
|
|
|
<nav> |
|
<h2><a href="index.html">Index</a></h2><ul><li><a href="index.html#installation">Installation</a></li><ul></ul><li><a href="index.html#usage">Usage</a></li><ul><li><a href="index.html#prerequisites">Prerequisites</a></li><li><a href="index.html#creating-an-ffmpeg-command">Creating an FFmpeg command</a></li><li><a href="index.html#specifying-inputs">Specifying inputs</a></li><li><a href="index.html#input-options">Input options</a></li><li><a href="index.html#audio-options">Audio options</a></li><li><a href="index.html#video-options">Video options</a></li><li><a href="index.html#video-frame-size-options">Video frame size options</a></li><li><a href="index.html#specifying-multiple-outputs">Specifying multiple outputs</a></li><li><a href="index.html#output-options">Output options</a></li><li><a href="index.html#miscellaneous-options">Miscellaneous options</a></li><li><a href="index.html#setting-event-handlers">Setting event handlers</a></li><li><a href="index.html#starting-ffmpeg-processing">Starting FFmpeg processing</a></li><li><a href="index.html#controlling-the-ffmpeg-process">Controlling the FFmpeg process</a></li><li><a href="index.html#reading-video-metadata">Reading video metadata</a></li><li><a href="index.html#querying-ffmpeg-capabilities">Querying ffmpeg capabilities</a></li><li><a href="index.html#cloning-an-ffmpegcommand">Cloning an FfmpegCommand</a></li></ul><li><a href="index.html#contributing">Contributing</a></li><ul><li><a href="index.html#code-contributions">Code contributions</a></li><li><a href="index.html#documentation-contributions">Documentation contributions</a></li><li><a href="index.html#updating-the-documentation">Updating the documentation</a></li><li><a href="index.html#running-tests">Running tests</a></li></ul><li><a href="index.html#main-contributors">Main contributors</a></li><ul></ul><li><a href="index.html#license">License</a></li><ul></ul></ul><h3>Classes</h3><ul><li><a href="FfmpegCommand.html">FfmpegCommand</a></li><ul><li> <a href="FfmpegCommand.html#audio-methods">Audio methods</a></li><li> <a href="FfmpegCommand.html#capabilities-methods">Capabilities methods</a></li><li> <a href="FfmpegCommand.html#custom-options-methods">Custom options methods</a></li><li> <a href="FfmpegCommand.html#input-methods">Input methods</a></li><li> <a href="FfmpegCommand.html#metadata-methods">Metadata methods</a></li><li> <a href="FfmpegCommand.html#miscellaneous-methods">Miscellaneous methods</a></li><li> <a href="FfmpegCommand.html#other-methods">Other methods</a></li><li> <a href="FfmpegCommand.html#output-methods">Output methods</a></li><li> <a href="FfmpegCommand.html#processing-methods">Processing methods</a></li><li> <a href="FfmpegCommand.html#video-methods">Video methods</a></li><li> <a href="FfmpegCommand.html#video-size-methods">Video size methods</a></li></ul></ul> |
|
</nav> |
|
|
|
<br clear="both"> |
|
|
|
<footer> |
|
Documentation generated by <a href="https://github.com/jsdoc3/jsdoc">JSDoc 3.4.0</a> on Sun May 01 2016 12:10:37 GMT+0200 (CEST) |
|
</footer> |
|
|
|
<script> prettyPrint(); </script> |
|
<script src="scripts/linenumber.js"> </script> |
|
</body> |
|
</html> |
|
|
