| <!DOCTYPE html> |
| <html lang="en"> |
| <head> |
| <meta charset="utf-8"> |
| <title>JSDoc: Source: processor.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: processor.js</h1> |
|
|
| |
|
|
|
|
| |
| <section> |
| <article> |
| <pre class="prettyprint source linenums"><code>/*jshint node:true*/ |
| 'use strict'; |
|
|
| var spawn = require('child_process').spawn; |
| var path = require('path'); |
| var fs = require('fs'); |
| var async = require('async'); |
| var utils = require('./utils'); |
|
|
| var nlRegexp = /\r\n|\r|\n/g; |
|
|
| /* |
| *! Processor methods |
| */ |
|
|
|
|
| /** |
| * Run ffprobe asynchronously and store data in command |
| * |
| * @param {FfmpegCommand} command |
| * @private |
| */ |
| function runFfprobe(command) { |
| command.ffprobe(0, function(err, data) { |
| command._ffprobeData = data; |
| }); |
| } |
|
|
|
|
| module.exports = function(proto) { |
| /** |
| * Emitted just after ffmpeg has been spawned. |
| * |
| * @event FfmpegCommand#start |
| * @param {String} command ffmpeg command line |
| */ |
|
|
| /** |
| * Emitted when ffmpeg reports progress information |
| * |
| * @event FfmpegCommand#progress |
| * @param {Object} progress progress object |
| * @param {Number} progress.frames number of frames transcoded |
| * @param {Number} progress.currentFps current processing speed in frames per second |
| * @param {Number} progress.currentKbps current output generation speed in kilobytes per second |
| * @param {Number} progress.targetSize current output file size |
| * @param {String} progress.timemark current video timemark |
| * @param {Number} [progress.percent] processing progress (may not be available depending on input) |
| */ |
|
|
| /** |
| * Emitted when ffmpeg outputs to stderr |
| * |
| * @event FfmpegCommand#stderr |
| * @param {String} line stderr output line |
| */ |
|
|
| /** |
| * Emitted when ffmpeg reports input codec data |
| * |
| * @event FfmpegCommand#codecData |
| * @param {Object} codecData codec data object |
| * @param {String} codecData.format input format name |
| * @param {String} codecData.audio input audio codec name |
| * @param {String} codecData.audio_details input audio codec parameters |
| * @param {String} codecData.video input video codec name |
| * @param {String} codecData.video_details input video codec parameters |
| */ |
|
|
| /** |
| * Emitted when an error happens when preparing or running a command |
| * |
| * @event FfmpegCommand#error |
| * @param {Error} error error object |
| * @param {String|null} stdout ffmpeg stdout, unless outputting to a stream |
| * @param {String|null} stderr ffmpeg stderr |
| */ |
|
|
| /** |
| * Emitted when a command finishes processing |
| * |
| * @event FfmpegCommand#end |
| * @param {Array|String|null} [filenames|stdout] generated filenames when taking screenshots, ffmpeg stdout when not outputting to a stream, null otherwise |
| * @param {String|null} stderr ffmpeg stderr |
| */ |
|
|
|
|
| /** |
| * Spawn an ffmpeg process |
| * |
| * The 'options' argument may contain the following keys: |
| * - 'niceness': specify process niceness, ignored on Windows (default: 0) |
| * - `cwd`: change working directory |
| * - 'captureStdout': capture stdout and pass it to 'endCB' as its 2nd argument (default: false) |
| * - 'stdoutLines': override command limit (default: use command limit) |
| * |
| * The 'processCB' callback, if present, is called as soon as the process is created and |
| * receives a nodejs ChildProcess object. It may not be called at all if an error happens |
| * before spawning the process. |
| * |
| * The 'endCB' callback is called either when an error occurs or when the ffmpeg process finishes. |
| * |
| * @method FfmpegCommand#_spawnFfmpeg |
| * @param {Array} args ffmpeg command line argument list |
| * @param {Object} [options] spawn options (see above) |
| * @param {Function} [processCB] callback called with process object and stdout/stderr ring buffers when process has been created |
| * @param {Function} endCB callback called with error (if applicable) and stdout/stderr ring buffers when process finished |
| * @private |
| */ |
| proto._spawnFfmpeg = function(args, options, processCB, endCB) { |
| // Enable omitting options |
| if (typeof options === 'function') { |
| endCB = processCB; |
| processCB = options; |
| options = {}; |
| } |
|
|
| // Enable omitting processCB |
| if (typeof endCB === 'undefined') { |
| endCB = processCB; |
| processCB = function() {}; |
| } |
|
|
| var maxLines = 'stdoutLines' in options ? options.stdoutLines : this.options.stdoutLines; |
|
|
| // Find ffmpeg |
| this._getFfmpegPath(function(err, command) { |
| if (err) { |
| return endCB(err); |
| } else if (!command || command.length === 0) { |
| return endCB(new Error('Cannot find ffmpeg')); |
| } |
|
|
| // Apply niceness |
| if (options.niceness && options.niceness !== 0 && !utils.isWindows) { |
| args.unshift('-n', options.niceness, command); |
| command = 'nice'; |
| } |
|
|
| var stdoutRing = utils.linesRing(maxLines); |
| var stdoutClosed = false; |
|
|
| var stderrRing = utils.linesRing(maxLines); |
| var stderrClosed = false; |
|
|
| // Spawn process |
| var ffmpegProc = spawn(command, args, options); |
|
|
| if (ffmpegProc.stderr) { |
| ffmpegProc.stderr.setEncoding('utf8'); |
| } |
|
|
| ffmpegProc.on('error', function(err) { |
| endCB(err); |
| }); |
|
|
| // Ensure we wait for captured streams to end before calling endCB |
| var exitError = null; |
| function handleExit(err) { |
| if (err) { |
| exitError = err; |
| } |
|
|
| if (processExited && (stdoutClosed || !options.captureStdout) && stderrClosed) { |
| endCB(exitError, stdoutRing, stderrRing); |
| } |
| } |
|
|
| // Handle process exit |
| var processExited = false; |
| ffmpegProc.on('exit', function(code, signal) { |
| processExited = true; |
|
|
| if (signal) { |
| handleExit(new Error('ffmpeg was killed with signal ' + signal)); |
| } else if (code) { |
| handleExit(new Error('ffmpeg exited with code ' + code)); |
| } else { |
| handleExit(); |
| } |
| }); |
|
|
| // Capture stdout if specified |
| if (options.captureStdout) { |
| ffmpegProc.stdout.on('data', function(data) { |
| stdoutRing.append(data); |
| }); |
|
|
| ffmpegProc.stdout.on('close', function() { |
| stdoutRing.close(); |
| stdoutClosed = true; |
| handleExit(); |
| }); |
| } |
|
|
| // Capture stderr if specified |
| ffmpegProc.stderr.on('data', function(data) { |
| stderrRing.append(data); |
| }); |
|
|
| ffmpegProc.stderr.on('close', function() { |
| stderrRing.close(); |
| stderrClosed = true; |
| handleExit(); |
| }); |
|
|
| // Call process callback |
| processCB(ffmpegProc, stdoutRing, stderrRing); |
| }); |
| }; |
|
|
|
|
| /** |
| * Build the argument list for an ffmpeg command |
| * |
| * @method FfmpegCommand#_getArguments |
| * @return argument list |
| * @private |
| */ |
| proto._getArguments = function() { |
| var complexFilters = this._complexFilters.get(); |
|
|
| var fileOutput = this._outputs.some(function(output) { |
| return output.isFile; |
| }); |
|
|
| return [].concat( |
| // Inputs and input options |
| this._inputs.reduce(function(args, input) { |
| var source = (typeof input.source === 'string') ? input.source : 'pipe:0'; |
|
|
| // For each input, add input options, then '-i <source>' |
| return args.concat( |
| input.options.get(), |
| ['-i', source] |
| ); |
| }, []), |
|
|
| // Global options |
| this._global.get(), |
|
|
| // Overwrite if we have file outputs |
| fileOutput ? ['-y'] : [], |
|
|
| // Complex filters |
| complexFilters, |
|
|
| // Outputs, filters and output options |
| this._outputs.reduce(function(args, output) { |
| var sizeFilters = utils.makeFilterStrings(output.sizeFilters.get()); |
| var audioFilters = output.audioFilters.get(); |
| var videoFilters = output.videoFilters.get().concat(sizeFilters); |
| var outputArg; |
|
|
| if (!output.target) { |
| outputArg = []; |
| } else if (typeof output.target === 'string') { |
| outputArg = [output.target]; |
| } else { |
| outputArg = ['pipe:1']; |
| } |
|
|
| return args.concat( |
| output.audio.get(), |
| audioFilters.length ? ['-filter:a', audioFilters.join(',')] : [], |
| output.video.get(), |
| videoFilters.length ? ['-filter:v', videoFilters.join(',')] : [], |
| output.options.get(), |
| outputArg |
| ); |
| }, []) |
| ); |
| }; |
|
|
|
|
| /** |
| * Prepare execution of an ffmpeg command |
| * |
| * Checks prerequisites for the execution of the command (codec/format availability, flvtool...), |
| * then builds the argument list for ffmpeg and pass them to 'callback'. |
| * |
| * @method FfmpegCommand#_prepare |
| * @param {Function} callback callback with signature (err, args) |
| * @param {Boolean} [readMetadata=false] read metadata before processing |
| * @private |
| */ |
| proto._prepare = function(callback, readMetadata) { |
| var self = this; |
|
|
| async.waterfall([ |
| // Check codecs and formats |
| function(cb) { |
| self._checkCapabilities(cb); |
| }, |
|
|
| // Read metadata if required |
| function(cb) { |
| if (!readMetadata) { |
| return cb(); |
| } |
|
|
| self.ffprobe(0, function(err, data) { |
| if (!err) { |
| self._ffprobeData = data; |
| } |
|
|
| cb(); |
| }); |
| }, |
|
|
| // Check for flvtool2/flvmeta if necessary |
| function(cb) { |
| var flvmeta = self._outputs.some(function(output) { |
| // Remove flvmeta flag on non-file output |
| if (output.flags.flvmeta && !output.isFile) { |
| self.logger.warn('Updating flv metadata is only supported for files'); |
| output.flags.flvmeta = false; |
| } |
|
|
| return output.flags.flvmeta; |
| }); |
|
|
| if (flvmeta) { |
| self._getFlvtoolPath(function(err) { |
| cb(err); |
| }); |
| } else { |
| cb(); |
| } |
| }, |
|
|
| // Build argument list |
| function(cb) { |
| var args; |
| try { |
| args = self._getArguments(); |
| } catch(e) { |
| return cb(e); |
| } |
|
|
| cb(null, args); |
| }, |
|
|
| // Add "-strict experimental" option where needed |
| function(args, cb) { |
| self.availableEncoders(function(err, encoders) { |
| for (var i = 0; i < args.length; i++) { |
| if (args[i] === '-acodec' || args[i] === '-vcodec') { |
| i++; |
|
|
| if ((args[i] in encoders) && encoders[args[i]].experimental) { |
| args.splice(i + 1, 0, '-strict', 'experimental'); |
| i += 2; |
| } |
| } |
| } |
|
|
| cb(null, args); |
| }); |
| } |
| ], callback); |
|
|
| if (!readMetadata) { |
| // Read metadata as soon as 'progress' listeners are added |
|
|
| if (this.listeners('progress').length > 0) { |
| // Read metadata in parallel |
| runFfprobe(this); |
| } else { |
| // Read metadata as soon as the first 'progress' listener is added |
| this.once('newListener', function(event) { |
| if (event === 'progress') { |
| runFfprobe(this); |
| } |
| }); |
| } |
| } |
| }; |
|
|
|
|
| /** |
| * Run ffmpeg command |
| * |
| * @method FfmpegCommand#run |
| * @category Processing |
| * @aliases exec,execute |
| */ |
| proto.exec = |
| proto.execute = |
| proto.run = function() { |
| var self = this; |
|
|
| // Check if at least one output is present |
| var outputPresent = this._outputs.some(function(output) { |
| return 'target' in output; |
| }); |
|
|
| if (!outputPresent) { |
| throw new Error('No output specified'); |
| } |
|
|
| // Get output stream if any |
| var outputStream = this._outputs.filter(function(output) { |
| return typeof output.target !== 'string'; |
| })[0]; |
|
|
| // Get input stream if any |
| var inputStream = this._inputs.filter(function(input) { |
| return typeof input.source !== 'string'; |
| })[0]; |
|
|
| // Ensure we send 'end' or 'error' only once |
| var ended = false; |
| function emitEnd(err, stdout, stderr) { |
| if (!ended) { |
| ended = true; |
|
|
| if (err) { |
| self.emit('error', err, stdout, stderr); |
| } else { |
| self.emit('end', stdout, stderr); |
| } |
| } |
| } |
|
|
| self._prepare(function(err, args) { |
| if (err) { |
| return emitEnd(err); |
| } |
|
|
| // Run ffmpeg |
| self._spawnFfmpeg( |
| args, |
| { |
| captureStdout: !outputStream, |
| niceness: self.options.niceness, |
| cwd: self.options.cwd |
| }, |
|
|
| function processCB(ffmpegProc, stdoutRing, stderrRing) { |
| self.ffmpegProc = ffmpegProc; |
| self.emit('start', 'ffmpeg ' + args.join(' ')); |
|
|
| // Pipe input stream if any |
| if (inputStream) { |
| inputStream.source.on('error', function(err) { |
| emitEnd(new Error('Input stream error: ' + err.message)); |
| ffmpegProc.kill(); |
| }); |
|
|
| inputStream.source.resume(); |
| inputStream.source.pipe(ffmpegProc.stdin); |
|
|
| // Set stdin error handler on ffmpeg (prevents nodejs catching the error, but |
| // ffmpeg will fail anyway, so no need to actually handle anything) |
| ffmpegProc.stdin.on('error', function() {}); |
| } |
|
|
| // Setup timeout if requested |
| var processTimer; |
| if (self.options.timeout) { |
| processTimer = setTimeout(function() { |
| var msg = 'process ran into a timeout (' + self.options.timeout + 's)'; |
|
|
| emitEnd(new Error(msg), stdoutRing.get(), stderrRing.get()); |
| ffmpegProc.kill(); |
| }, self.options.timeout * 1000); |
| } |
|
|
|
|
| if (outputStream) { |
| // Pipe ffmpeg stdout to output stream |
| ffmpegProc.stdout.pipe(outputStream.target, outputStream.pipeopts); |
|
|
| // Handle output stream events |
| outputStream.target.on('close', function() { |
| self.logger.debug('Output stream closed, scheduling kill for ffmpgeg process'); |
|
|
| // Don't kill process yet, to give a chance to ffmpeg to |
| // terminate successfully first This is necessary because |
| // under load, the process 'exit' event sometimes happens |
| // after the output stream 'close' event. |
| setTimeout(function() { |
| emitEnd(new Error('Output stream closed')); |
| ffmpegProc.kill(); |
| }, 20); |
| }); |
|
|
| outputStream.target.on('error', function(err) { |
| self.logger.debug('Output stream error, killing ffmpgeg process'); |
| emitEnd(new Error('Output stream error: ' + err.message), stdoutRing.get(), stderrRing.get()); |
| ffmpegProc.kill(); |
| }); |
| } |
|
|
| // Setup stderr handling |
| if (stderrRing) { |
|
|
| // 'stderr' event |
| if (self.listeners('stderr').length) { |
| stderrRing.callback(function(line) { |
| self.emit('stderr', line); |
| }); |
| } |
|
|
| // 'codecData' event |
| if (self.listeners('codecData').length) { |
| var codecDataSent = false; |
| var codecObject = {}; |
|
|
| stderrRing.callback(function(line) { |
| if (!codecDataSent) |
| codecDataSent = utils.extractCodecData(self, line, codecObject); |
| }); |
| } |
|
|
| // 'progress' event |
| if (self.listeners('progress').length) { |
| var duration = 0; |
|
|
| if (self._ffprobeData && self._ffprobeData.format && self._ffprobeData.format.duration) { |
| duration = Number(self._ffprobeData.format.duration); |
| } |
|
|
| stderrRing.callback(function(line) { |
| utils.extractProgress(self, line, duration); |
| }); |
| } |
| } |
| }, |
|
|
| function endCB(err, stdoutRing, stderrRing) { |
| delete self.ffmpegProc; |
|
|
| if (err) { |
| if (err.message.match(/ffmpeg exited with code/)) { |
| // Add ffmpeg error message |
| err.message += ': ' + utils.extractError(stderrRing.get()); |
| } |
|
|
| emitEnd(err, stdoutRing.get(), stderrRing.get()); |
| } else { |
| // Find out which outputs need flv metadata |
| var flvmeta = self._outputs.filter(function(output) { |
| return output.flags.flvmeta; |
| }); |
|
|
| if (flvmeta.length) { |
| self._getFlvtoolPath(function(err, flvtool) { |
| if (err) { |
| return emitEnd(err); |
| } |
|
|
| async.each( |
| flvmeta, |
| function(output, cb) { |
| spawn(flvtool, ['-U', output.target]) |
| .on('error', function(err) { |
| cb(new Error('Error running ' + flvtool + ' on ' + output.target + ': ' + err.message)); |
| }) |
| .on('exit', function(code, signal) { |
| if (code !== 0 || signal) { |
| cb( |
| new Error(flvtool + ' ' + |
| (signal ? 'received signal ' + signal |
| : 'exited with code ' + code)) + |
| ' when running on ' + output.target |
| ); |
| } else { |
| cb(); |
| } |
| }); |
| }, |
| function(err) { |
| if (err) { |
| emitEnd(err); |
| } else { |
| emitEnd(null, stdoutRing.get(), stderrRing.get()); |
| } |
| } |
| ); |
| }); |
| } else { |
| emitEnd(null, stdoutRing.get(), stderrRing.get()); |
| } |
| } |
| } |
| ); |
| }); |
| }; |
|
|
|
|
| /** |
| * Renice current and/or future ffmpeg processes |
| * |
| * Ignored on Windows platforms. |
| * |
| * @method FfmpegCommand#renice |
| * @category Processing |
| * |
| * @param {Number} [niceness=0] niceness value between -20 (highest priority) and 20 (lowest priority) |
| * @return FfmpegCommand |
| */ |
| proto.renice = function(niceness) { |
| if (!utils.isWindows) { |
| niceness = niceness || 0; |
|
|
| if (niceness < -20 || niceness > 20) { |
| this.logger.warn('Invalid niceness value: ' + niceness + ', must be between -20 and 20'); |
| } |
|
|
| niceness = Math.min(20, Math.max(-20, niceness)); |
| this.options.niceness = niceness; |
|
|
| if (this.ffmpegProc) { |
| var logger = this.logger; |
| var pid = this.ffmpegProc.pid; |
| var renice = spawn('renice', [niceness, '-p', pid]); |
|
|
| renice.on('error', function(err) { |
| logger.warn('could not renice process ' + pid + ': ' + err.message); |
| }); |
|
|
| renice.on('exit', function(code, signal) { |
| if (signal) { |
| logger.warn('could not renice process ' + pid + ': renice was killed by signal ' + signal); |
| } else if (code) { |
| logger.warn('could not renice process ' + pid + ': renice exited with ' + code); |
| } else { |
| logger.info('successfully reniced process ' + pid + ' to ' + niceness + ' niceness'); |
| } |
| }); |
| } |
| } |
|
|
| return this; |
| }; |
|
|
|
|
| /** |
| * Kill current ffmpeg process, if any |
| * |
| * @method FfmpegCommand#kill |
| * @category Processing |
| * |
| * @param {String} [signal=SIGKILL] signal name |
| * @return FfmpegCommand |
| */ |
| proto.kill = function(signal) { |
| if (!this.ffmpegProc) { |
| this.logger.warn('No running ffmpeg process, cannot send signal'); |
| } else { |
| this.ffmpegProc.kill(signal || 'SIGKILL'); |
| } |
|
|
| 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> |
|
|
