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