How to use the fluent-ffmpeg function in fluent-ffmpeg

fs.writeFile(file, res.audioContent, 'binary', (err) => {
      if (err) {
        log.error(`Google Cloud TTS: ${err}`)
        return
      }

      const ffmpeg = new Ffmpeg()
      ffmpeg.setFfmpegPath(ffmpegPath)
      ffmpeg.setFfprobePath(ffprobePath)

      // Get file duration thanks to ffprobe
      ffmpeg.input(file).ffprobe((err, data) => {
        if (err) log.error(err)
        else {
          const duration = data.streams[0].duration * 1000
          em.emit('saved', duration)
          cb(file, duration)
        }
      })
    })
  })

return new Promise(resolve => {
            // @ts-ignore FIXME:
            ffmpeg(source)
              .size(size)
              .on('end', (stdout: string, stderr: string) => {
                processFiles(rest).then(() => {
                  resolve();
                });
              })
              .save(target);
          });
        });

return new Promise((resolve, reject) => {
        console.log(ffmpegPath);
        let command = ffmpeg();
        command.setFfmpegPath(ffmpegPath)
        command.input("\"\"")
        command.inputFormat("avfoundation")
        .inputOptions([
            "-list_devices true",
        ])
        .on('start', commandLine => {
            console.log('Spawned Ffmpeg with command: ' + commandLine);
        })
        .on('error', (err, one, two) => {
            if (err & !two) {
                return reject();
            }
            var mode = null;
            var data = two.split("\n");
            var devices = [];

detectVirtualAudioDeviceWindows (redetection) {
        let command = ffmpeg("dummy");
        command.setFfmpegPath(ffmpegPath);
        command.inputOptions([
            "-list_devices true",
            "-f dshow",
        ])
        return new Promise((resolve, reject) => {
            command.outputOptions([])
                .on('start', commandLine => {
                    console.log('Spawned Ffmpeg with command: ' + commandLine);
                })
                .on('error', (err, one, two) => {
                    if (one, two) {
                        if (two.indexOf("virtual-audio-capturer") > -1) {
                            console.log("VIRTUAL DEVICE FOUND");
                            resolve();
                        } else if (redetection) {

return new Promise(resolve => {
    ffmpeg(file).ffprobe((err, meta) => {
      if (err) return;
      const { duration } = meta.format;
      const interval = Math.ceil(duration / (count + 1));
      const timemarks = new Array(count)
        .fill(0)
        .map((v, i) => interval * (i + 1));
      Promise.all(timemarks.map(mark => walk(mark)))
        .then(() => resolve(file))
        .catch(error => {
          console.error(error);
        });
    });
  });
};

const info = await new Promise((resolve, reject) => {
      ffmpeg(path).ffprobe(function(err, data) {
        if (err) reject(err)
        resolve(data)
      })
    })

createffmpeg() {
    let logCounter = 0;
    const ffmpeg = fluentffmpeg()

    .outputOptions([

    ])

    .on("error", (err, stdout, stderr) => {
      if (this.deleted) {
        return;
      }
      this.error("ffmpeg error", {err: err.toString(), stdout, stderr});
      this.retry();
    })

    .on("codecData", (data) => {
      this.info("ffmpeg codecData", data);
      this.updateSelf({

return new Promise((resolve, reject) => {
      ffmpeg()
        .input(inputPath)
        .ffprobe((err, data) => {
          if (err) {
            reject(err);
          } else {
            resolve(data);
          }
        });
    });
  }

export default function ffmpeg() {
  let logCounter = 0;
  const thisFfmpeg = fluent()
    .on("error", (err, stdout, stderr) => {
      if (err.toString() === "Error: ffmpeg was killed with signal SIGKILL") {
        return;
      }
      log("ffmpeg error", { err: err.toString() });
      log(stdout);
      log(stderr);
    })
    .on("codecData", data => {
      log("ffmpeg codecData", data);
    })
    .on("end", () => {
      log("ffmpeg end");
      allFfmpegs = allFfmpegs.filter(x => x !== thisFfmpeg);
    })
    .on("progress", data => {

const wrappedffmpeg = function(name) {

  const streamLog = bunyan.createLogger({name: `${name} (${streamCount})`});
  streamCount += 1;

  return ffmpeg({
    logger: {
      error: streamLog.error,
      warning: streamLog.warn,
      info: streamLog.info,
      debug: streamLog.debug,
    }
  })
    .on("error", function(err, stdout, stderr) {
      streamLog.error("fired event: error");
      streamLog.error("err", err);
      streamLog.error("stdout", stdout);
      streamLog.error("stderr", stderr);
    })
    .on("codecData", function(data) {
      streamLog.info("fired event: codecData", data);
    })