| <!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> |
|
|
