|
<!DOCTYPE html> |
|
<html lang="en"> |
|
<head> |
|
<meta charset="utf-8"> |
|
<title>JSDoc: Source: recipes.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: recipes.js</h1> |
|
|
|
|
|
|
|
|
|
|
|
<section> |
|
<article> |
|
<pre class="prettyprint source linenums"><code>/*jshint node:true*/ |
|
'use strict'; |
|
|
|
var fs = require('fs'); |
|
var path = require('path'); |
|
var PassThrough = require('stream').PassThrough; |
|
var async = require('async'); |
|
var utils = require('./utils'); |
|
|
|
|
|
/* |
|
* Useful recipes for commands |
|
*/ |
|
|
|
module.exports = function recipes(proto) { |
|
/** |
|
* Execute ffmpeg command and save output to a file |
|
* |
|
* @method FfmpegCommand#save |
|
* @category Processing |
|
* @aliases saveToFile |
|
* |
|
* @param {String} output file path |
|
* @return FfmpegCommand |
|
*/ |
|
proto.saveToFile = |
|
proto.save = function(output) { |
|
this.output(output).run(); |
|
return this; |
|
}; |
|
|
|
|
|
/** |
|
* Execute ffmpeg command and save output to a stream |
|
* |
|
* If 'stream' is not specified, a PassThrough stream is created and returned. |
|
* 'options' will be used when piping ffmpeg output to the output stream |
|
* (@see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options) |
|
* |
|
* @method FfmpegCommand#pipe |
|
* @category Processing |
|
* @aliases stream,writeToStream |
|
* |
|
* @param {stream.Writable} [stream] output stream |
|
* @param {Object} [options={}] pipe options |
|
* @return Output stream |
|
*/ |
|
proto.writeToStream = |
|
proto.pipe = |
|
proto.stream = function(stream, options) { |
|
if (stream && !('writable' in stream)) { |
|
options = stream; |
|
stream = undefined; |
|
} |
|
|
|
if (!stream) { |
|
if (process.version.match(/v0\.8\./)) { |
|
throw new Error('PassThrough stream is not supported on node v0.8'); |
|
} |
|
|
|
stream = new PassThrough(); |
|
} |
|
|
|
this.output(stream, options).run(); |
|
return stream; |
|
}; |
|
|
|
|
|
/** |
|
* Generate images from a video |
|
* |
|
* Note: this method makes the command emit a 'filenames' event with an array of |
|
* the generated image filenames. |
|
* |
|
* @method FfmpegCommand#screenshots |
|
* @category Processing |
|
* @aliases takeScreenshots,thumbnail,thumbnails,screenshot |
|
* |
|
* @param {Number|Object} [config=1] screenshot count or configuration object with |
|
* the following keys: |
|
* @param {Number} [config.count] number of screenshots to take; using this option |
|
* takes screenshots at regular intervals (eg. count=4 would take screens at 20%, 40%, |
|
* 60% and 80% of the video length). |
|
* @param {String} [config.folder='.'] output folder |
|
* @param {String} [config.filename='tn.png'] output filename pattern, may contain the following |
|
* tokens: |
|
* - '%s': offset in seconds |
|
* - '%w': screenshot width |
|
* - '%h': screenshot height |
|
* - '%r': screenshot resolution (same as '%wx%h') |
|
* - '%f': input filename |
|
* - '%b': input basename (filename w/o extension) |
|
* - '%i': index of screenshot in timemark array (can be zero-padded by using it like `%000i`) |
|
* @param {Number[]|String[]} [config.timemarks] array of timemarks to take screenshots |
|
* at; each timemark may be a number of seconds, a '[[hh:]mm:]ss[.xxx]' string or a |
|
* 'XX%' string. Overrides 'count' if present. |
|
* @param {Number[]|String[]} [config.timestamps] alias for 'timemarks' |
|
* @param {Boolean} [config.fastSeek] use fast seek (less accurate) |
|
* @param {String} [config.size] screenshot size, with the same syntax as {@link FfmpegCommand#size} |
|
* @param {String} [folder] output folder (legacy alias for 'config.folder') |
|
* @return FfmpegCommand |
|
*/ |
|
proto.takeScreenshots = |
|
proto.thumbnail = |
|
proto.thumbnails = |
|
proto.screenshot = |
|
proto.screenshots = function(config, folder) { |
|
var self = this; |
|
var source = this._currentInput.source; |
|
config = config || { count: 1 }; |
|
|
|
// Accept a number of screenshots instead of a config object |
|
if (typeof config === 'number') { |
|
config = { |
|
count: config |
|
}; |
|
} |
|
|
|
// Accept a second 'folder' parameter instead of config.folder |
|
if (!('folder' in config)) { |
|
config.folder = folder || '.'; |
|
} |
|
|
|
// Accept 'timestamps' instead of 'timemarks' |
|
if ('timestamps' in config) { |
|
config.timemarks = config.timestamps; |
|
} |
|
|
|
// Compute timemarks from count if not present |
|
if (!('timemarks' in config)) { |
|
if (!config.count) { |
|
throw new Error('Cannot take screenshots: neither a count nor a timemark list are specified'); |
|
} |
|
|
|
var interval = 100 / (1 + config.count); |
|
config.timemarks = []; |
|
for (var i = 0; i < config.count; i++) { |
|
config.timemarks.push((interval * (i + 1)) + '%'); |
|
} |
|
} |
|
|
|
// Parse size option |
|
if ('size' in config) { |
|
var fixedSize = config.size.match(/^(\d+)x(\d+)$/); |
|
var fixedWidth = config.size.match(/^(\d+)x\?$/); |
|
var fixedHeight = config.size.match(/^\?x(\d+)$/); |
|
var percentSize = config.size.match(/^(\d+)%$/); |
|
|
|
if (!fixedSize && !fixedWidth && !fixedHeight && !percentSize) { |
|
throw new Error('Invalid size parameter: ' + config.size); |
|
} |
|
} |
|
|
|
// Metadata helper |
|
var metadata; |
|
function getMetadata(cb) { |
|
if (metadata) { |
|
cb(null, metadata); |
|
} else { |
|
self.ffprobe(function(err, meta) { |
|
metadata = meta; |
|
cb(err, meta); |
|
}); |
|
} |
|
} |
|
|
|
async.waterfall([ |
|
// Compute percent timemarks if any |
|
function computeTimemarks(next) { |
|
if (config.timemarks.some(function(t) { return ('' + t).match(/^[\d.]+%$/); })) { |
|
if (typeof source !== 'string') { |
|
return next(new Error('Cannot compute screenshot timemarks with an input stream, please specify fixed timemarks')); |
|
} |
|
|
|
getMetadata(function(err, meta) { |
|
if (err) { |
|
next(err); |
|
} else { |
|
// Select video stream with the highest resolution |
|
var vstream = meta.streams.reduce(function(biggest, stream) { |
|
if (stream.codec_type === 'video' && stream.width * stream.height > biggest.width * biggest.height) { |
|
return stream; |
|
} else { |
|
return biggest; |
|
} |
|
}, { width: 0, height: 0 }); |
|
|
|
if (vstream.width === 0) { |
|
return next(new Error('No video stream in input, cannot take screenshots')); |
|
} |
|
|
|
var duration = Number(vstream.duration); |
|
if (isNaN(duration)) { |
|
duration = Number(meta.format.duration); |
|
} |
|
|
|
if (isNaN(duration)) { |
|
return next(new Error('Could not get input duration, please specify fixed timemarks')); |
|
} |
|
|
|
config.timemarks = config.timemarks.map(function(mark) { |
|
if (('' + mark).match(/^([\d.]+)%$/)) { |
|
return duration * parseFloat(mark) / 100; |
|
} else { |
|
return mark; |
|
} |
|
}); |
|
|
|
next(); |
|
} |
|
}); |
|
} else { |
|
next(); |
|
} |
|
}, |
|
|
|
// Turn all timemarks into numbers and sort them |
|
function normalizeTimemarks(next) { |
|
config.timemarks = config.timemarks.map(function(mark) { |
|
return utils.timemarkToSeconds(mark); |
|
}).sort(function(a, b) { return a - b; }); |
|
|
|
next(); |
|
}, |
|
|
|
// Add '_%i' to pattern when requesting multiple screenshots and no variable token is present |
|
function fixPattern(next) { |
|
var pattern = config.filename || 'tn.png'; |
|
|
|
if (pattern.indexOf('.') === -1) { |
|
pattern += '.png'; |
|
} |
|
|
|
if (config.timemarks.length > 1 && !pattern.match(/%(s|0*i)/)) { |
|
var ext = path.extname(pattern); |
|
pattern = path.join(path.dirname(pattern), path.basename(pattern, ext) + '_%i' + ext); |
|
} |
|
|
|
next(null, pattern); |
|
}, |
|
|
|
// Replace filename tokens (%f, %b) in pattern |
|
function replaceFilenameTokens(pattern, next) { |
|
if (pattern.match(/%[bf]/)) { |
|
if (typeof source !== 'string') { |
|
return next(new Error('Cannot replace %f or %b when using an input stream')); |
|
} |
|
|
|
pattern = pattern |
|
.replace(/%f/g, path.basename(source)) |
|
.replace(/%b/g, path.basename(source, path.extname(source))); |
|
} |
|
|
|
next(null, pattern); |
|
}, |
|
|
|
// Compute size if needed |
|
function getSize(pattern, next) { |
|
if (pattern.match(/%[whr]/)) { |
|
if (fixedSize) { |
|
return next(null, pattern, fixedSize[1], fixedSize[2]); |
|
} |
|
|
|
getMetadata(function(err, meta) { |
|
if (err) { |
|
return next(new Error('Could not determine video resolution to replace %w, %h or %r')); |
|
} |
|
|
|
var vstream = meta.streams.reduce(function(biggest, stream) { |
|
if (stream.codec_type === 'video' && stream.width * stream.height > biggest.width * biggest.height) { |
|
return stream; |
|
} else { |
|
return biggest; |
|
} |
|
}, { width: 0, height: 0 }); |
|
|
|
if (vstream.width === 0) { |
|
return next(new Error('No video stream in input, cannot replace %w, %h or %r')); |
|
} |
|
|
|
var width = vstream.width; |
|
var height = vstream.height; |
|
|
|
if (fixedWidth) { |
|
height = height * Number(fixedWidth[1]) / width; |
|
width = Number(fixedWidth[1]); |
|
} else if (fixedHeight) { |
|
width = width * Number(fixedHeight[1]) / height; |
|
height = Number(fixedHeight[1]); |
|
} else if (percentSize) { |
|
width = width * Number(percentSize[1]) / 100; |
|
height = height * Number(percentSize[1]) / 100; |
|
} |
|
|
|
next(null, pattern, Math.round(width / 2) * 2, Math.round(height / 2) * 2); |
|
}); |
|
} else { |
|
next(null, pattern, -1, -1); |
|
} |
|
}, |
|
|
|
// Replace size tokens (%w, %h, %r) in pattern |
|
function replaceSizeTokens(pattern, width, height, next) { |
|
pattern = pattern |
|
.replace(/%r/g, '%wx%h') |
|
.replace(/%w/g, width) |
|
.replace(/%h/g, height); |
|
|
|
next(null, pattern); |
|
}, |
|
|
|
// Replace variable tokens in pattern (%s, %i) and generate filename list |
|
function replaceVariableTokens(pattern, next) { |
|
var filenames = config.timemarks.map(function(t, i) { |
|
return pattern |
|
.replace(/%s/g, utils.timemarkToSeconds(t)) |
|
.replace(/%(0*)i/g, function(match, padding) { |
|
var idx = '' + (i + 1); |
|
return padding.substr(0, Math.max(0, padding.length + 1 - idx.length)) + idx; |
|
}); |
|
}); |
|
|
|
self.emit('filenames', filenames); |
|
next(null, filenames); |
|
}, |
|
|
|
// Create output directory |
|
function createDirectory(filenames, next) { |
|
fs.exists(config.folder, function(exists) { |
|
if (!exists) { |
|
fs.mkdir(config.folder, function(err) { |
|
if (err) { |
|
next(err); |
|
} else { |
|
next(null, filenames); |
|
} |
|
}); |
|
} else { |
|
next(null, filenames); |
|
} |
|
}); |
|
} |
|
], function runCommand(err, filenames) { |
|
if (err) { |
|
return self.emit('error', err); |
|
} |
|
|
|
var count = config.timemarks.length; |
|
var split; |
|
var filters = [split = { |
|
filter: 'split', |
|
options: count, |
|
outputs: [] |
|
}]; |
|
|
|
if ('size' in config) { |
|
// Set size to generate size filters |
|
self.size(config.size); |
|
|
|
// Get size filters and chain them with 'sizeN' stream names |
|
var sizeFilters = self._currentOutput.sizeFilters.get().map(function(f, i) { |
|
if (i > 0) { |
|
f.inputs = 'size' + (i - 1); |
|
} |
|
|
|
f.outputs = 'size' + i; |
|
|
|
return f; |
|
}); |
|
|
|
// Input last size filter output into split filter |
|
split.inputs = 'size' + (sizeFilters.length - 1); |
|
|
|
// Add size filters in front of split filter |
|
filters = sizeFilters.concat(filters); |
|
|
|
// Remove size filters |
|
self._currentOutput.sizeFilters.clear(); |
|
} |
|
|
|
var first = 0; |
|
for (var i = 0; i < count; i++) { |
|
var stream = 'screen' + i; |
|
split.outputs.push(stream); |
|
|
|
if (i === 0) { |
|
first = config.timemarks[i]; |
|
self.seekInput(first); |
|
} |
|
|
|
self.output(path.join(config.folder, filenames[i])) |
|
.frames(1) |
|
.map(stream); |
|
|
|
if (i > 0) { |
|
self.seek(config.timemarks[i] - first); |
|
} |
|
} |
|
|
|
self.complexFilter(filters); |
|
self.run(); |
|
}); |
|
|
|
return this; |
|
}; |
|
|
|
|
|
/** |
|
* Merge (concatenate) inputs to a single file |
|
* |
|
* @method FfmpegCommand#concat |
|
* @category Processing |
|
* @aliases concatenate,mergeToFile |
|
* |
|
* @param {String|Writable} target output file or writable stream |
|
* @param {Object} [options] pipe options (only used when outputting to a writable stream) |
|
* @return FfmpegCommand |
|
*/ |
|
proto.mergeToFile = |
|
proto.concatenate = |
|
proto.concat = function(target, options) { |
|
// Find out which streams are present in the first non-stream input |
|
var fileInput = this._inputs.filter(function(input) { |
|
return !input.isStream; |
|
})[0]; |
|
|
|
var self = this; |
|
this.ffprobe(this._inputs.indexOf(fileInput), function(err, data) { |
|
if (err) { |
|
return self.emit('error', err); |
|
} |
|
|
|
var hasAudioStreams = data.streams.some(function(stream) { |
|
return stream.codec_type === 'audio'; |
|
}); |
|
|
|
var hasVideoStreams = data.streams.some(function(stream) { |
|
return stream.codec_type === 'video'; |
|
}); |
|
|
|
// Setup concat filter and start processing |
|
self.output(target, options) |
|
.complexFilter({ |
|
filter: 'concat', |
|
options: { |
|
n: self._inputs.length, |
|
v: hasVideoStreams ? 1 : 0, |
|
a: hasAudioStreams ? 1 : 0 |
|
} |
|
}) |
|
.run(); |
|
}); |
|
|
|
return this; |
|
}; |
|
}; |
|
</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> |
|
|
