Source: processor.js

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