fluent-ffmpeg / node-fluent-ffmpeg / 6854001414

import { FfmpegInput, InputOptions } from './input'

import { FfmpegOutput, OutputOptions } from './output'

import { FfmpegProcess, RunResult, RunOptions } from './process'

type CommandOptions = {

  input?: InputOptions

  inputs?: InputOptions[]

  output?: OutputOptions

  outputs?: OutputOptions[]

}

export class FfmpegCommand implements CommandOptions {

  inputs: FfmpegInput[]

  outputs: FfmpegOutput[]

  constructor(options: CommandOptions) {

    if (options.input) {

      options.inputs = [options.input]

    }

    if (options.output) {

      options.outputs = [options.output]

    }

    this.inputs = (options.inputs || []).map(

      (inputOptions) => new FfmpegInput(inputOptions)

    )

    this.outputs = (options.outputs || []).map(

      (outputOptions) => new FfmpegOutput(outputOptions)

    )

    this.validateIO()

  }

  validateIO(): void {

    if (this.inputs.filter((i) => i.isStream).length > 1) {

      throw new Error(`At most one stream input is supported`)

    }

    if (this.outputs.filter((o) => o.isStream).length > 1) {

      throw new Error(`At most one stream output is supported`)

    }

  }

  getFfmpegArguments(): string[] {

    let args: string[] = []

    for (let input of this.inputs) {

      args.push(...input.getFfmpegArguments())

    }

    // TODO complex filters

    if (this.outputs.some((o) => o.isLocalFile)) {

      // Force overwrite outputs

      args.push('-y')

    }

    for (let output of this.outputs) {

      args.push(...output.getFfmpegArguments())

    }

    return args

  }

  run(options: RunOptions): Promise<RunResult> {

    let proc = new FfmpegProcess({

      args: this.getFfmpegArguments(),

      ...options

    })

    return proc.run()

  }

}