path: root/players.js

// stolen from http-music

const { spawn } = require('child_process')
const FIFO = require('fifo-js')
const EventEmitter = require('events')
const { commandExists, killProcess, getTimeStrings } = require('./general-util')

class Player extends EventEmitter {
  constructor() {
    super()

    this.disablePlaybackStatus = false
    this.isLooping = false
    this.isPaused = false
    this.volume = 100
  }

  set process(newProcess) {
    this._process = newProcess
    this._process.on('exit', code => {
      if (code !== 0 && !this._killed) {
        this.emit('crashed', code)
      }

      this._killed = false
    })
  }

  get process() {
    return this._process
  }

  playFile(file) {}
  seekAhead(secs) {}
  seekBack(secs) {}
  volUp(amount) {}
  volDown(amount) {}
  togglePause() {}
  toggleLoop() {}
  setPause() {}
  setLoop() {}

  async kill() {
    if (this.process) {
      this._killed = true
      await killProcess(this.process)
    }
  }

  printStatusLine(data) {
    // Quick sanity check - we don't want to print the status line if it's
    // disabled! Hopefully printStatusLine won't be called in that case, but
    // if it is, we should be careful.
    if (!this.disablePlaybackStatus) {
      this.emit('printStatusLine', data)
    }
  }
}

module.exports.MPVPlayer = class extends Player {
  getMPVOptions(file) {
    const opts = ['--no-video', file]
    if (this.isLooping) {
      opts.unshift('--loop')
    }
    opts.unshift('--volume', this.volume)
    return opts
  }

  playFile(file) {
    // The more powerful MPV player. MPV is virtually impossible for a human
    // being to install; if you're having trouble with it, try the SoX player.

    this.isPaused = false
    this.process = spawn('mpv', this.getMPVOptions(file))

    let lastPercent = 0

    this.process.stderr.on('data', data => {
      if (this.disablePlaybackStatus) {
        return
      }

      const match = data.toString().match(
        /(..):(..):(..) \/ (..):(..):(..) \(([0-9]+)%\)/
      )

      if (match) {
        const [
          curHour, curMin, curSec, // ##:##:##
          lenHour, lenMin, lenSec, // ##:##:##
          percent // ###%
        ] = match.slice(1)

        if (lastPercent < parseInt(percent)) {
          lastPercent = parseInt(percent)
          // mpv forgets commands you sent it whenever it loops, so you
          // have to specify them every time it loops. We do that whenever the
          // position in the song decreases, since that means it may have
          // looped.
          if (this.isLooping) {
            this.sendCommand('set loop yes')
          } else {
            this.sendCommand('set loop no')
          }
        }

        this.printStatusLine(getTimeStrings({curHour, curMin, curSec, lenHour, lenMin, lenSec}))
      }
    })

    return new Promise(resolve => {
      this.process.once('close', resolve)
    })
  }
}

module.exports.ControllableMPVPlayer = class extends module.exports.MPVPlayer {
  getMPVOptions(file) {
    return ['--input-file=' + this.fifo.path, ...super.getMPVOptions(file)]
  }

  playFile(file) {
    this.fifo = new FIFO()

    return super.playFile(file)
  }

  sendCommand(command) {
    if (this.fifo) {
      this.fifo.write(command)
    }
  }

  seekAhead(secs) {
    this.sendCommand(`seek +${parseFloat(secs)}`)
  }

  seekBack(secs) {
    this.sendCommand(`seek -${parseFloat(secs)}`)
  }

  volUp(amount) {
    this.volume = Math.min(100, this.volume + amount)
    this.sendCommand(`set volume ${this.volume}`)
  }

  volDown(amount) {
    this.volume = Math.max(0, this.volume - amount)
    this.sendCommand(`set volume ${this.volume}`)
  }

  togglePause() {
    this.isPaused = !this.isPaused
    this.sendCommand('cycle pause')
  }

  toggleLoop() {
    this.isLooping = !this.isLooping
    this.sendCommand('cycle loop')
  }

  setPause(val) {
    this.isPaused = !!val
    this.sendCommand('set pause ' + (val ? 'yes' : 'no'))
  }

  setLoop(val) {
    this.isLooping = !!val
    this.sendCommand('set loop ' + (val ? 'yes' : 'no'))
  }

  kill() {
    if (this.fifo) {
      this.fifo.close()
      delete this.fifo
    }

    return super.kill()
  }
}

module.exports.SoXPlayer = class extends Player {
  playFile(file) {
    // SoX's play command is useful for systems that don't have MPV. SoX is
    // much easier to install (and probably more commonly installed, as well).
    // You don't get keyboard controls such as seeking or volume adjusting
    // with SoX, though.

    this.process = spawn('play', [file])

    this.process.stdout.on('data', data => {
      process.stdout.write(data.toString())
    })

    // Most output from SoX is given to stderr, for some reason!
    this.process.stderr.on('data', data => {
      // The status line starts with "In:".
      if (data.toString().trim().startsWith('In:')) {
        if (this.disablePlaybackStatus) {
          return
        }

        const timeRegex = '([0-9]*):([0-9]*):([0-9]*)\.([0-9]*)'
        const match = data.toString().trim().match(new RegExp(
          `^In:([0-9.]+%)\\s*${timeRegex}\\s*\\[${timeRegex}\\]`
        ))

        if (match) {
          const percentStr = match[1]

          // SoX takes a loooooot of math in order to actually figure out the
          // duration, since it outputs the current time and the remaining time
          // (but not the duration).

          const [
            curHour, curMin, curSec, curSecFrac, // ##:##:##.##
            remHour, remMin, remSec, remSecFrac // ##:##:##.##
          ] = match.slice(2).map(n => parseInt(n))

          const duration = Math.round(
            (curHour + remHour) * 3600 +
            (curMin + remMin) * 60 +
            (curSec + remSec) * 1 +
            (curSecFrac + remSecFrac) / 100
          )

          const lenHour = Math.floor(duration / 3600)
          const lenMin = Math.floor((duration - lenHour * 3600) / 60)
          const lenSec = Math.floor(duration - lenHour * 3600 - lenMin * 60)

          this.printStatusLine(getTimeStrings({curHour, curMin, curSec, lenHour, lenMin, lenSec}))
        }
      }
    })

    return new Promise(resolve => {
      this.process.on('close', () => resolve())
    })
  }
}

module.exports.getPlayer = async function() {
  if (await commandExists('mpv')) {
    if (await commandExists('mkfifo')) {
      return new module.exports.ControllableMPVPlayer()
    } else {
      return new module.exports.MPVPlayer()
    }
  } else if (await commandExists('play')) {
    return new module.exports.SoXPlayer()
  } else {
    return null
  }
}