buddy

FFmpeg.js (4689B)

---

 const ChildProcess = require('child_process');
 const { Duplex } = require('stream');
 
 let FFMPEG = {
   command: null,
   output: null,
 };
 
 const VERSION_REGEX = /version (.+) Copyright/mi;
 
 Object.defineProperty(FFMPEG, 'version', {
   get() {
     return VERSION_REGEX.exec(FFMPEG.output)[1];
   },
   enumerable: true,
 });
 
 /**
  * An FFmpeg transform stream that provides an interface to FFmpeg.
  * @memberof core
  */
 class FFmpeg extends Duplex {
   /**
    * Creates a new FFmpeg transform stream
    * @memberof core
    * @param {Object} options Options you would pass to a regular Transform stream, plus an `args` option
    * @param {Array<string>} options.args Arguments to pass to FFmpeg
    * @example
    * // By default, if you don't specify an input (`-i ...`) prism will assume you're piping a stream into it.
    * const transcoder = new prism.FFmpeg({
    *  args: [
    *    '-analyzeduration', '0',
    *    '-loglevel', '0',
    *    '-f', 's16le',
    *    '-ar', '48000',
    *    '-ac', '2',
    *  ]
    * });
    * const s16le = mp3File.pipe(transcoder);
    * const opus = s16le.pipe(new prism.opus.Encoder({ rate: 48000, channels: 2, frameSize: 960 }));
    */
   constructor(options = {}) {
     super();
     this.process = FFmpeg.create(options);
     const EVENTS = {
       readable: this._reader,
       data: this._reader,
       end: this._reader,
       unpipe: this._reader,
       finish: this._writer,
       drain: this._writer,
     };
 
     this._readableState = this._reader._readableState;
     this._writableState = this._writer._writableState;
 
     this._copy(['write', 'end'], this._writer);
     this._copy(['read', 'setEncoding', 'pipe', 'unpipe'], this._reader);
 
     for (const method of ['on', 'once', 'removeListener', 'removeListeners', 'listeners']) {
       this[method] = (ev, fn) => EVENTS[ev] ? EVENTS[ev][method](ev, fn) : Duplex.prototype[method].call(this, ev, fn);
     }
 
     const processError = error => this.emit('error', error);
     this._reader.on('error', processError);
     this._writer.on('error', processError);
   }
 
   get _reader() { return this.process.stdout; }
   get _writer() { return this.process.stdin; }
 
   _copy(methods, target) {
     for (const method of methods) {
       this[method] = target[method].bind(target);
     }
   }
 
   _destroy(err, cb) {
     super._destroy(err, cb);
     this.once('error', () => {});
     this.process.kill('SIGKILL');
   }
 
 
   /**
    * The available FFmpeg information
    * @typedef {Object} FFmpegInfo
    * @memberof core
    * @property {string} command The command used to launch FFmpeg
    * @property {string} output The output from running `ffmpeg -h`
    * @property {string} version The version of FFmpeg being used, determined from `output`.
    */
 
   /**
    * Finds a suitable FFmpeg command and obtains the debug information from it.
    * @param {boolean} [force=false] If true, will ignore any cached results and search for the command again
    * @returns {FFmpegInfo}
    * @throws Will throw an error if FFmpeg cannot be found.
    * @example
    * const ffmpeg = prism.FFmpeg.getInfo();
    *
    * console.log(`Using FFmpeg version ${ffmpeg.version}`);
    *
    * if (ffmpeg.output.includes('--enable-libopus')) {
    *   console.log('libopus is available!');
    * } else {
    *   console.log('libopus is unavailable!');
    * }
    */
   static getInfo(force = false) {
     if (FFMPEG.command && !force) return FFMPEG;
     const sources = [() => {
       const ffmpegStatic = require('ffmpeg-static');
       return ffmpegStatic.path || ffmpegStatic;
     }, 'ffmpeg', 'avconv', './ffmpeg', './avconv'];
     for (let source of sources) {
       try {
         if (typeof source === 'function') source = source();
         const result = ChildProcess.spawnSync(source, ['-h'], { windowsHide: true });
         if (result.error) throw result.error;
         Object.assign(FFMPEG, {
           command: source,
           output: Buffer.concat(result.output.filter(Boolean)).toString(),
         });
         return FFMPEG;
       } catch (error) {
         // Do nothing
       }
     }
     throw new Error('FFmpeg/avconv not found!');
   }
 
   /**
    * Creates a new FFmpeg instance. If you do not include `-i ...` it will be assumed that `-i -` should be prepended
    * to the options and that you'll be piping data into the process.
    * @param {String[]} [args=[]] Arguments to pass to FFmpeg
    * @returns {ChildProcess}
    * @private
    * @throws Will throw an error if FFmpeg cannot be found.
    */
   static create({ args = [] } = {}) {
     if (!args.includes('-i')) args.unshift('-i', '-');
     return ChildProcess.spawn(FFmpeg.getInfo().command, args.concat(['pipe:1']), { windowsHide: true });
   }
 }
 
 module.exports = FFmpeg;