processor.js.html 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4. <meta charset="utf-8">
  5. <title>JSDoc: Source: processor.js</title>
  6. <script src="scripts/prettify/prettify.js"> </script>
  7. <script src="scripts/prettify/lang-css.js"> </script>
  8. <!--[if lt IE 9]>
  9. <script src="//html5shiv.googlecode.com/svn/trunk/html5.js"></script>
  10. <![endif]-->
  11. <link type="text/css" rel="stylesheet" href="styles/prettify-tomorrow.css">
  12. <link type="text/css" rel="stylesheet" href="styles/jsdoc-default.css">
  13. </head>
  14. <body>
  15. <div id="main">
  16. <h1 class="page-title">Source: processor.js</h1>
  17. <section>
  18. <article>
  19. <pre class="prettyprint source linenums"><code>/*jshint node:true*/
  20. 'use strict';
  21. var spawn = require('child_process').spawn;
  22. var path = require('path');
  23. var fs = require('fs');
  24. var async = require('async');
  25. var utils = require('./utils');
  26. var nlRegexp = /\r\n|\r|\n/g;
  27. /*
  28. *! Processor methods
  29. */
  30. /**
  31. * Run ffprobe asynchronously and store data in command
  32. *
  33. * @param {FfmpegCommand} command
  34. * @private
  35. */
  36. function runFfprobe(command) {
  37. command.ffprobe(0, function(err, data) {
  38. command._ffprobeData = data;
  39. });
  40. }
  41. module.exports = function(proto) {
  42. /**
  43. * Emitted just after ffmpeg has been spawned.
  44. *
  45. * @event FfmpegCommand#start
  46. * @param {String} command ffmpeg command line
  47. */
  48. /**
  49. * Emitted when ffmpeg reports progress information
  50. *
  51. * @event FfmpegCommand#progress
  52. * @param {Object} progress progress object
  53. * @param {Number} progress.frames number of frames transcoded
  54. * @param {Number} progress.currentFps current processing speed in frames per second
  55. * @param {Number} progress.currentKbps current output generation speed in kilobytes per second
  56. * @param {Number} progress.targetSize current output file size
  57. * @param {String} progress.timemark current video timemark
  58. * @param {Number} [progress.percent] processing progress (may not be available depending on input)
  59. */
  60. /**
  61. * Emitted when ffmpeg outputs to stderr
  62. *
  63. * @event FfmpegCommand#stderr
  64. * @param {String} line stderr output line
  65. */
  66. /**
  67. * Emitted when ffmpeg reports input codec data
  68. *
  69. * @event FfmpegCommand#codecData
  70. * @param {Object} codecData codec data object
  71. * @param {String} codecData.format input format name
  72. * @param {String} codecData.audio input audio codec name
  73. * @param {String} codecData.audio_details input audio codec parameters
  74. * @param {String} codecData.video input video codec name
  75. * @param {String} codecData.video_details input video codec parameters
  76. */
  77. /**
  78. * Emitted when an error happens when preparing or running a command
  79. *
  80. * @event FfmpegCommand#error
  81. * @param {Error} error error object
  82. * @param {String|null} stdout ffmpeg stdout, unless outputting to a stream
  83. * @param {String|null} stderr ffmpeg stderr
  84. */
  85. /**
  86. * Emitted when a command finishes processing
  87. *
  88. * @event FfmpegCommand#end
  89. * @param {Array|String|null} [filenames|stdout] generated filenames when taking screenshots, ffmpeg stdout when not outputting to a stream, null otherwise
  90. * @param {String|null} stderr ffmpeg stderr
  91. */
  92. /**
  93. * Spawn an ffmpeg process
  94. *
  95. * The 'options' argument may contain the following keys:
  96. * - 'niceness': specify process niceness, ignored on Windows (default: 0)
  97. * - `cwd`: change working directory
  98. * - 'captureStdout': capture stdout and pass it to 'endCB' as its 2nd argument (default: false)
  99. * - 'stdoutLines': override command limit (default: use command limit)
  100. *
  101. * The 'processCB' callback, if present, is called as soon as the process is created and
  102. * receives a nodejs ChildProcess object. It may not be called at all if an error happens
  103. * before spawning the process.
  104. *
  105. * The 'endCB' callback is called either when an error occurs or when the ffmpeg process finishes.
  106. *
  107. * @method FfmpegCommand#_spawnFfmpeg
  108. * @param {Array} args ffmpeg command line argument list
  109. * @param {Object} [options] spawn options (see above)
  110. * @param {Function} [processCB] callback called with process object and stdout/stderr ring buffers when process has been created
  111. * @param {Function} endCB callback called with error (if applicable) and stdout/stderr ring buffers when process finished
  112. * @private
  113. */
  114. proto._spawnFfmpeg = function(args, options, processCB, endCB) {
  115. // Enable omitting options
  116. if (typeof options === 'function') {
  117. endCB = processCB;
  118. processCB = options;
  119. options = {};
  120. }
  121. // Enable omitting processCB
  122. if (typeof endCB === 'undefined') {
  123. endCB = processCB;
  124. processCB = function() {};
  125. }
  126. var maxLines = 'stdoutLines' in options ? options.stdoutLines : this.options.stdoutLines;
  127. // Find ffmpeg
  128. this._getFfmpegPath(function(err, command) {
  129. if (err) {
  130. return endCB(err);
  131. } else if (!command || command.length === 0) {
  132. return endCB(new Error('Cannot find ffmpeg'));
  133. }
  134. // Apply niceness
  135. if (options.niceness &amp;&amp; options.niceness !== 0 &amp;&amp; !utils.isWindows) {
  136. args.unshift('-n', options.niceness, command);
  137. command = 'nice';
  138. }
  139. var stdoutRing = utils.linesRing(maxLines);
  140. var stdoutClosed = false;
  141. var stderrRing = utils.linesRing(maxLines);
  142. var stderrClosed = false;
  143. // Spawn process
  144. var ffmpegProc = spawn(command, args, options);
  145. if (ffmpegProc.stderr) {
  146. ffmpegProc.stderr.setEncoding('utf8');
  147. }
  148. ffmpegProc.on('error', function(err) {
  149. endCB(err);
  150. });
  151. // Ensure we wait for captured streams to end before calling endCB
  152. var exitError = null;
  153. function handleExit(err) {
  154. if (err) {
  155. exitError = err;
  156. }
  157. if (processExited &amp;&amp; (stdoutClosed || !options.captureStdout) &amp;&amp; stderrClosed) {
  158. endCB(exitError, stdoutRing, stderrRing);
  159. }
  160. }
  161. // Handle process exit
  162. var processExited = false;
  163. ffmpegProc.on('exit', function(code, signal) {
  164. processExited = true;
  165. if (signal) {
  166. handleExit(new Error('ffmpeg was killed with signal ' + signal));
  167. } else if (code) {
  168. handleExit(new Error('ffmpeg exited with code ' + code));
  169. } else {
  170. handleExit();
  171. }
  172. });
  173. // Capture stdout if specified
  174. if (options.captureStdout) {
  175. ffmpegProc.stdout.on('data', function(data) {
  176. stdoutRing.append(data);
  177. });
  178. ffmpegProc.stdout.on('close', function() {
  179. stdoutRing.close();
  180. stdoutClosed = true;
  181. handleExit();
  182. });
  183. }
  184. // Capture stderr if specified
  185. ffmpegProc.stderr.on('data', function(data) {
  186. stderrRing.append(data);
  187. });
  188. ffmpegProc.stderr.on('close', function() {
  189. stderrRing.close();
  190. stderrClosed = true;
  191. handleExit();
  192. });
  193. // Call process callback
  194. processCB(ffmpegProc, stdoutRing, stderrRing);
  195. });
  196. };
  197. /**
  198. * Build the argument list for an ffmpeg command
  199. *
  200. * @method FfmpegCommand#_getArguments
  201. * @return argument list
  202. * @private
  203. */
  204. proto._getArguments = function() {
  205. var complexFilters = this._complexFilters.get();
  206. var fileOutput = this._outputs.some(function(output) {
  207. return output.isFile;
  208. });
  209. return [].concat(
  210. // Inputs and input options
  211. this._inputs.reduce(function(args, input) {
  212. var source = (typeof input.source === 'string') ? input.source : 'pipe:0';
  213. // For each input, add input options, then '-i &lt;source>'
  214. return args.concat(
  215. input.options.get(),
  216. ['-i', source]
  217. );
  218. }, []),
  219. // Global options
  220. this._global.get(),
  221. // Overwrite if we have file outputs
  222. fileOutput ? ['-y'] : [],
  223. // Complex filters
  224. complexFilters,
  225. // Outputs, filters and output options
  226. this._outputs.reduce(function(args, output) {
  227. var sizeFilters = utils.makeFilterStrings(output.sizeFilters.get());
  228. var audioFilters = output.audioFilters.get();
  229. var videoFilters = output.videoFilters.get().concat(sizeFilters);
  230. var outputArg;
  231. if (!output.target) {
  232. outputArg = [];
  233. } else if (typeof output.target === 'string') {
  234. outputArg = [output.target];
  235. } else {
  236. outputArg = ['pipe:1'];
  237. }
  238. return args.concat(
  239. output.audio.get(),
  240. audioFilters.length ? ['-filter:a', audioFilters.join(',')] : [],
  241. output.video.get(),
  242. videoFilters.length ? ['-filter:v', videoFilters.join(',')] : [],
  243. output.options.get(),
  244. outputArg
  245. );
  246. }, [])
  247. );
  248. };
  249. /**
  250. * Prepare execution of an ffmpeg command
  251. *
  252. * Checks prerequisites for the execution of the command (codec/format availability, flvtool...),
  253. * then builds the argument list for ffmpeg and pass them to 'callback'.
  254. *
  255. * @method FfmpegCommand#_prepare
  256. * @param {Function} callback callback with signature (err, args)
  257. * @param {Boolean} [readMetadata=false] read metadata before processing
  258. * @private
  259. */
  260. proto._prepare = function(callback, readMetadata) {
  261. var self = this;
  262. async.waterfall([
  263. // Check codecs and formats
  264. function(cb) {
  265. self._checkCapabilities(cb);
  266. },
  267. // Read metadata if required
  268. function(cb) {
  269. if (!readMetadata) {
  270. return cb();
  271. }
  272. self.ffprobe(0, function(err, data) {
  273. if (!err) {
  274. self._ffprobeData = data;
  275. }
  276. cb();
  277. });
  278. },
  279. // Check for flvtool2/flvmeta if necessary
  280. function(cb) {
  281. var flvmeta = self._outputs.some(function(output) {
  282. // Remove flvmeta flag on non-file output
  283. if (output.flags.flvmeta &amp;&amp; !output.isFile) {
  284. self.logger.warn('Updating flv metadata is only supported for files');
  285. output.flags.flvmeta = false;
  286. }
  287. return output.flags.flvmeta;
  288. });
  289. if (flvmeta) {
  290. self._getFlvtoolPath(function(err) {
  291. cb(err);
  292. });
  293. } else {
  294. cb();
  295. }
  296. },
  297. // Build argument list
  298. function(cb) {
  299. var args;
  300. try {
  301. args = self._getArguments();
  302. } catch(e) {
  303. return cb(e);
  304. }
  305. cb(null, args);
  306. },
  307. // Add "-strict experimental" option where needed
  308. function(args, cb) {
  309. self.availableEncoders(function(err, encoders) {
  310. for (var i = 0; i &lt; args.length; i++) {
  311. if (args[i] === '-acodec' || args[i] === '-vcodec') {
  312. i++;
  313. if ((args[i] in encoders) &amp;&amp; encoders[args[i]].experimental) {
  314. args.splice(i + 1, 0, '-strict', 'experimental');
  315. i += 2;
  316. }
  317. }
  318. }
  319. cb(null, args);
  320. });
  321. }
  322. ], callback);
  323. if (!readMetadata) {
  324. // Read metadata as soon as 'progress' listeners are added
  325. if (this.listeners('progress').length > 0) {
  326. // Read metadata in parallel
  327. runFfprobe(this);
  328. } else {
  329. // Read metadata as soon as the first 'progress' listener is added
  330. this.once('newListener', function(event) {
  331. if (event === 'progress') {
  332. runFfprobe(this);
  333. }
  334. });
  335. }
  336. }
  337. };
  338. /**
  339. * Run ffmpeg command
  340. *
  341. * @method FfmpegCommand#run
  342. * @category Processing
  343. * @aliases exec,execute
  344. */
  345. proto.exec =
  346. proto.execute =
  347. proto.run = function() {
  348. var self = this;
  349. // Check if at least one output is present
  350. var outputPresent = this._outputs.some(function(output) {
  351. return 'target' in output;
  352. });
  353. if (!outputPresent) {
  354. throw new Error('No output specified');
  355. }
  356. // Get output stream if any
  357. var outputStream = this._outputs.filter(function(output) {
  358. return typeof output.target !== 'string';
  359. })[0];
  360. // Get input stream if any
  361. var inputStream = this._inputs.filter(function(input) {
  362. return typeof input.source !== 'string';
  363. })[0];
  364. // Ensure we send 'end' or 'error' only once
  365. var ended = false;
  366. function emitEnd(err, stdout, stderr) {
  367. if (!ended) {
  368. ended = true;
  369. if (err) {
  370. self.emit('error', err, stdout, stderr);
  371. } else {
  372. self.emit('end', stdout, stderr);
  373. }
  374. }
  375. }
  376. self._prepare(function(err, args) {
  377. if (err) {
  378. return emitEnd(err);
  379. }
  380. // Run ffmpeg
  381. self._spawnFfmpeg(
  382. args,
  383. {
  384. captureStdout: !outputStream,
  385. niceness: self.options.niceness,
  386. cwd: self.options.cwd
  387. },
  388. function processCB(ffmpegProc, stdoutRing, stderrRing) {
  389. self.ffmpegProc = ffmpegProc;
  390. self.emit('start', 'ffmpeg ' + args.join(' '));
  391. // Pipe input stream if any
  392. if (inputStream) {
  393. inputStream.source.on('error', function(err) {
  394. emitEnd(new Error('Input stream error: ' + err.message));
  395. ffmpegProc.kill();
  396. });
  397. inputStream.source.resume();
  398. inputStream.source.pipe(ffmpegProc.stdin);
  399. // Set stdin error handler on ffmpeg (prevents nodejs catching the error, but
  400. // ffmpeg will fail anyway, so no need to actually handle anything)
  401. ffmpegProc.stdin.on('error', function() {});
  402. }
  403. // Setup timeout if requested
  404. var processTimer;
  405. if (self.options.timeout) {
  406. processTimer = setTimeout(function() {
  407. var msg = 'process ran into a timeout (' + self.options.timeout + 's)';
  408. emitEnd(new Error(msg), stdoutRing.get(), stderrRing.get());
  409. ffmpegProc.kill();
  410. }, self.options.timeout * 1000);
  411. }
  412. if (outputStream) {
  413. // Pipe ffmpeg stdout to output stream
  414. ffmpegProc.stdout.pipe(outputStream.target, outputStream.pipeopts);
  415. // Handle output stream events
  416. outputStream.target.on('close', function() {
  417. self.logger.debug('Output stream closed, scheduling kill for ffmpgeg process');
  418. // Don't kill process yet, to give a chance to ffmpeg to
  419. // terminate successfully first This is necessary because
  420. // under load, the process 'exit' event sometimes happens
  421. // after the output stream 'close' event.
  422. setTimeout(function() {
  423. emitEnd(new Error('Output stream closed'));
  424. ffmpegProc.kill();
  425. }, 20);
  426. });
  427. outputStream.target.on('error', function(err) {
  428. self.logger.debug('Output stream error, killing ffmpgeg process');
  429. emitEnd(new Error('Output stream error: ' + err.message), stdoutRing.get(), stderrRing.get());
  430. ffmpegProc.kill();
  431. });
  432. }
  433. // Setup stderr handling
  434. if (stderrRing) {
  435. // 'stderr' event
  436. if (self.listeners('stderr').length) {
  437. stderrRing.callback(function(line) {
  438. self.emit('stderr', line);
  439. });
  440. }
  441. // 'codecData' event
  442. if (self.listeners('codecData').length) {
  443. var codecDataSent = false;
  444. var codecObject = {};
  445. stderrRing.callback(function(line) {
  446. if (!codecDataSent)
  447. codecDataSent = utils.extractCodecData(self, line, codecObject);
  448. });
  449. }
  450. // 'progress' event
  451. if (self.listeners('progress').length) {
  452. var duration = 0;
  453. if (self._ffprobeData &amp;&amp; self._ffprobeData.format &amp;&amp; self._ffprobeData.format.duration) {
  454. duration = Number(self._ffprobeData.format.duration);
  455. }
  456. stderrRing.callback(function(line) {
  457. utils.extractProgress(self, line, duration);
  458. });
  459. }
  460. }
  461. },
  462. function endCB(err, stdoutRing, stderrRing) {
  463. delete self.ffmpegProc;
  464. if (err) {
  465. if (err.message.match(/ffmpeg exited with code/)) {
  466. // Add ffmpeg error message
  467. err.message += ': ' + utils.extractError(stderrRing.get());
  468. }
  469. emitEnd(err, stdoutRing.get(), stderrRing.get());
  470. } else {
  471. // Find out which outputs need flv metadata
  472. var flvmeta = self._outputs.filter(function(output) {
  473. return output.flags.flvmeta;
  474. });
  475. if (flvmeta.length) {
  476. self._getFlvtoolPath(function(err, flvtool) {
  477. if (err) {
  478. return emitEnd(err);
  479. }
  480. async.each(
  481. flvmeta,
  482. function(output, cb) {
  483. spawn(flvtool, ['-U', output.target])
  484. .on('error', function(err) {
  485. cb(new Error('Error running ' + flvtool + ' on ' + output.target + ': ' + err.message));
  486. })
  487. .on('exit', function(code, signal) {
  488. if (code !== 0 || signal) {
  489. cb(
  490. new Error(flvtool + ' ' +
  491. (signal ? 'received signal ' + signal
  492. : 'exited with code ' + code)) +
  493. ' when running on ' + output.target
  494. );
  495. } else {
  496. cb();
  497. }
  498. });
  499. },
  500. function(err) {
  501. if (err) {
  502. emitEnd(err);
  503. } else {
  504. emitEnd(null, stdoutRing.get(), stderrRing.get());
  505. }
  506. }
  507. );
  508. });
  509. } else {
  510. emitEnd(null, stdoutRing.get(), stderrRing.get());
  511. }
  512. }
  513. }
  514. );
  515. });
  516. };
  517. /**
  518. * Renice current and/or future ffmpeg processes
  519. *
  520. * Ignored on Windows platforms.
  521. *
  522. * @method FfmpegCommand#renice
  523. * @category Processing
  524. *
  525. * @param {Number} [niceness=0] niceness value between -20 (highest priority) and 20 (lowest priority)
  526. * @return FfmpegCommand
  527. */
  528. proto.renice = function(niceness) {
  529. if (!utils.isWindows) {
  530. niceness = niceness || 0;
  531. if (niceness &lt; -20 || niceness > 20) {
  532. this.logger.warn('Invalid niceness value: ' + niceness + ', must be between -20 and 20');
  533. }
  534. niceness = Math.min(20, Math.max(-20, niceness));
  535. this.options.niceness = niceness;
  536. if (this.ffmpegProc) {
  537. var logger = this.logger;
  538. var pid = this.ffmpegProc.pid;
  539. var renice = spawn('renice', [niceness, '-p', pid]);
  540. renice.on('error', function(err) {
  541. logger.warn('could not renice process ' + pid + ': ' + err.message);
  542. });
  543. renice.on('exit', function(code, signal) {
  544. if (signal) {
  545. logger.warn('could not renice process ' + pid + ': renice was killed by signal ' + signal);
  546. } else if (code) {
  547. logger.warn('could not renice process ' + pid + ': renice exited with ' + code);
  548. } else {
  549. logger.info('successfully reniced process ' + pid + ' to ' + niceness + ' niceness');
  550. }
  551. });
  552. }
  553. }
  554. return this;
  555. };
  556. /**
  557. * Kill current ffmpeg process, if any
  558. *
  559. * @method FfmpegCommand#kill
  560. * @category Processing
  561. *
  562. * @param {String} [signal=SIGKILL] signal name
  563. * @return FfmpegCommand
  564. */
  565. proto.kill = function(signal) {
  566. if (!this.ffmpegProc) {
  567. this.logger.warn('No running ffmpeg process, cannot send signal');
  568. } else {
  569. this.ffmpegProc.kill(signal || 'SIGKILL');
  570. }
  571. return this;
  572. };
  573. };
  574. </code></pre>
  575. </article>
  576. </section>
  577. </div>
  578. <nav>
  579. <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>
  580. </nav>
  581. <br clear="both">
  582. <footer>
  583. 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)
  584. </footer>
  585. <script> prettyPrint(); </script>
  586. <script src="scripts/linenumber.js"> </script>
  587. </body>
  588. </html>