segue 0.1.0

data/lib/segue/player.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "mpv"
+require_relative "paths"
+
+module Segue
+  # Drives a pair of mpv instances so one can fade up while the other fades
+  # down - mpv has no crossfade of its own.
+  class Player
+    MAX_VOLUME = 100
+    FADE_STEPS = 10
+    FADE_STEP_SECONDS = 0.5
+    QUIT_TIMEOUT = 2
+
+    def initialize(executable: ENV.fetch("SEGUE_MPV", "mpv"))
+      @executable = executable
+      @processes = []
+      @current = spawn_mpv("a")
+      @other = spawn_mpv("b")
+      @stopped = nil
+    end
+
+    def playing?
+      loaded? && @current.get("pause") == false
+    end
+
+    def time
+      (@current.get("time-pos") || 0).round
+    end
+
+    def remaining
+      duration = @current.get("duration")
+      return 0 unless duration
+
+      [(duration - (@current.get("time-pos") || 0)).round, 0].max
+    end
+
+    def fadeout
+      fade([@current, MAX_VOLUME, 0])
+    end
+
+    def fadein
+      @current.set("volume", 0)
+      play
+      fade([@current, 0, MAX_VOLUME])
+    end
+
+    def crossfade(path)
+      @other.set("volume", 0)
+      @other.load(path)
+      fade([@current, MAX_VOLUME, 0], [@other, 0, MAX_VOLUME])
+      @current.command("stop")
+      @current, @other = @other, @current
+      @stopped = nil
+    end
+
+    def play(path = nil)
+      if path
+        @current.set("volume", MAX_VOLUME)
+        @current.load(path)
+      elsif @stopped
+        @current.load(@stopped[:path], start: @stopped[:time])
+      else
+        @current.set("pause", false)
+      end
+      @stopped = nil
+    end
+
+    def pause
+      @current.set("pause", true)
+    end
+
+    # mpv unloads the file on stop, so remember where we were to let play resume.
+    def stop
+      @stopped = { path: @current.get("path"), time: @current.get("time-pos") }
+      @current.command("stop")
+    end
+
+    def cleanup
+      [@current, @other].compact.each(&:close)
+      @current = @other = nil
+      @processes.each do |pid, socket_path|
+        terminate pid
+        FileUtils.rm_f socket_path
+      end
+      @processes = []
+    end
+
+    private
+
+    def loaded?
+      @current.get("idle-active") == false
+    end
+
+    def spawn_mpv(name)
+      socket_path = Segue::Paths.socket(name)
+      FileUtils.rm_f socket_path
+      pid = Process.spawn(
+        @executable,
+        "--idle=yes",
+        "--no-video",
+        "--no-terminal",
+        "--volume=#{MAX_VOLUME}",
+        "--input-ipc-server=#{socket_path}",
+        %i[out err] => File::NULL
+      )
+      @processes << [pid, socket_path]
+      Mpv.new(socket_path).connect
+    end
+
+    # Each ramp is [mpv, from, to] and they all step together, which is what
+    # makes a crossfade a crossfade rather than two sequential fades.
+    def fade(*ramps)
+      (0..FADE_STEPS).each do |step|
+        ramps.each { |mpv, from, to| mpv.set("volume", level(from, to, step)) }
+        sleep FADE_STEP_SECONDS
+      end
+    end
+
+    def level(from, to, step)
+      from + (((to - from) * step) / FADE_STEPS)
+    end
+
+    def terminate(pid)
+      deadline = Time.now + QUIT_TIMEOUT
+      while Time.now < deadline
+        return if Process.waitpid(pid, Process::WNOHANG)
+
+        sleep Mpv::POLL_INTERVAL
+      end
+      Process.kill "TERM", pid
+      Process.waitpid pid
+    rescue Errno::ECHILD, Errno::ESRCH
+      nil
+    end
+  end
+end

data/lib/segue/player_controller.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative "player"
+require_relative "preferences"
+require_relative "queue"
+require_relative "notifiers"
+
+module Segue
+  class PlayerController
+    CROSSFADE_TRIGGER_SECONDS = 5
+
+    def initialize
+      @player = Segue::Player.new
+      @preferences = Segue::Preferences.new
+      @queue = Segue::Queue.new
+      @notifiers = Segue::Notifiers.new
+      @track = nil
+      @suspended = false
+    end
+
+    # An ordered chain of guard clauses - the priority between them is the
+    # point, so leave it flat rather than nesting it to please the metrics
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def next
+      return on_play if @preferences.play? && @suspended
+      return on_pause if @preferences.pause? && !@suspended
+      return on_stop if @preferences.stop? && !@suspended
+      return build if @suspended
+      return when_playing if @track && @player.playing?
+      return when_auto if @preferences.continue?
+
+      when_manual
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    def cleanup
+      @notifiers.track_suspended
+      @player.fadeout
+      @player.cleanup
+    end
+
+    private
+
+    def on_pause
+      suspend("Now Paused", :pause)
+    end
+
+    def on_stop
+      suspend("Now Stopped", :stop)
+    end
+
+    def suspend(status, method)
+      @player.fadeout
+      @player.send(method)
+      @status = status
+      @suspended = true
+      @notifiers.track_suspended
+      build
+    end
+
+    def on_play
+      @player.fadein
+      @suspended = false
+      @notifiers.track_resumed(@track, @player.time)
+      when_playing_track(@player.remaining)
+    end
+
+    def when_playing
+      return on_skip if @preferences.skip?
+      return on_crossfade if @preferences.crossfade? && @player.remaining < CROSSFADE_TRIGGER_SECONDS
+
+      when_playing_track(@player.remaining)
+    end
+
+    def on_skip
+      @notifiers.track_suspended
+      advance
+    end
+
+    def on_crossfade
+      @notifiers.track_finished(@track)
+      advance
+    end
+
+    def advance
+      @track = @queue.next
+      unless @track
+        @player.fadeout
+        return when_empty
+      end
+
+      @notifiers.track_started(@track)
+      @player.crossfade(@track[:path])
+      when_playing_track(@player.remaining)
+    end
+
+    def when_auto
+      @notifiers.track_finished(@track)
+      @track = @queue.next
+      return when_empty unless @track
+
+      @notifiers.track_started(@track)
+      @player.play(@track[:path])
+      when_playing_track(@track[:length])
+    end
+
+    def when_playing_track(remaining)
+      @status = "Now Playing"
+      remaining_color = remaining < 30 ? 9 : 5
+      build(
+        [2, @track[:title]],
+        [0, "\n"],
+        [0, "by "],
+        [11, @track[:artist]],
+        [0, "\n"],
+        [0, "from "],
+        [6, @track[:album]],
+        [0, "\n"],
+        [remaining_color, duration(remaining)],
+        [0, " of "],
+        [0, duration(@track[:length])],
+        [0, " remaining\n"]
+      )
+    end
+
+    def when_empty
+      @status = "Now Waiting"
+      build
+    end
+
+    def when_manual
+      @status = "Now Waiting"
+      build
+    end
+
+    def display_time(time)
+      time.strftime("%I:%M:%S")
+    end
+
+    def duration(seconds)
+      seconds = seconds.to_i
+      seconds > 60 ? "#{seconds / 60}m and #{seconds % 60}s" : "#{seconds}s"
+    end
+
+    def build(*extra)
+      autoplay = @preferences[:autoplay] ? "+" : "-"
+      crossfade = @preferences[:crossfade] ? "+" : "-"
+      scrobble = @preferences[:scrobble] ? "+" : "-"
+      [
+        [0, display_time(Time.now)],
+        [0, "\n"],
+        [0, @status],
+        [0, "\n"],
+        [0, "#{Segue::Queue.length} queued tracks"],
+        [0, "\n"],
+        [8, "#{autoplay}autoplay #{crossfade}crossfade #{scrobble}scrobble"],
+        [0, "\n"]
+      ] + extra
+    end
+  end
+end

data/lib/segue/preferences.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "paths"
+
+module Segue
+  class Preferences
+    def initialize
+      @path = Segue::Paths.preferences
+      persist({ autoplay: true, crossfade: true }) unless File.exist?(@path)
+    end
+
+    def continue?
+      self[:autoplay]
+    end
+
+    def crossfade?
+      self[:autoplay] && self[:crossfade]
+    end
+
+    def scrobble?
+      self[:scrobble]
+    end
+
+    def pause?
+      reset(:pause)
+    end
+
+    def stop?
+      reset(:stop)
+    end
+
+    def play?
+      reset(:play)
+    end
+
+    def skip?
+      reset(:skip)
+    end
+
+    def [](key)
+      load_preferences[key]
+    end
+
+    def []=(key, value)
+      preferences = load_preferences
+      preferences[key] = value
+      persist(preferences)
+    end
+
+    def persist(preferences)
+      File.open(@path, "w") { |f| f.puts preferences.to_yaml }
+    end
+
+    private
+
+    def load_preferences
+      YAML.load_file(@path)
+    end
+
+    def reset(key)
+      result = self[key]
+      self[key] = false if result
+      result
+    end
+  end
+end

data/lib/segue/queue.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+require_relative "ffmpeg"
+require_relative "paths"
+
+module Segue
+  # The queue is a directory of yaml files named after the time they were
+  # added, so ordering is just sorting by filename.
+  class Queue
+    EXTENSIONS = %w[.mp3 .m4a .flac .ogg .opus .wav .aac .wma].freeze
+
+    def initialize
+      @current_path = nil
+    end
+
+    def next
+      FileUtils.rm_f @current_path if @current_path
+      @current_path = Segue::Queue.entries.first
+      return unless @current_path
+
+      result = YAML.load_file(@current_path)
+      File.exist?(result[:path]) ? result : self.next
+    end
+
+    class << self
+      # Dir[] sorts its results, and the filenames are timestamps, so this is
+      # the queue in the order tracks were added
+      def entries
+        Dir[File.join(Segue::Paths.queue, "*.yml")]
+      end
+
+      def clear
+        FileUtils.rm_rf Segue::Paths.queue
+      end
+
+      def length
+        entries.length
+      end
+
+      def each
+        entries.each { |path| yield YAML.load_file(path) }
+      end
+
+      def remove(index)
+        path = entries[index.to_i]
+        if path
+          FileUtils.rm_f path
+          yield
+        else
+          puts "Could not find track at position #{index}"
+        end
+      end
+
+      def swap(index_a, index_b)
+        all = entries
+        path_a = all[index_a.to_i]
+        path_b = all[index_b.to_i]
+
+        if path_a && path_b
+          FileUtils.mv path_a, "#{path_a}.tmp"
+          FileUtils.mv path_b, path_a
+          FileUtils.mv "#{path_a}.tmp", path_b
+          yield
+        else
+          puts "Could not find tracks at positions #{index_a} and #{index_b}"
+        end
+      end
+
+      def add(path)
+        unless EXTENSIONS.include?(File.extname(path).downcase)
+          puts "skipping #{path}"
+          return
+        end
+
+        puts "adding #{path}"
+        tags = Segue::Ffmpeg.new(path)
+        enqueue(
+          title: tags.title,
+          artist: tags.artist,
+          album: tags.album,
+          length: tags.time,
+          path: File.expand_path(path)
+        )
+      end
+
+      def enqueue(track)
+        File.open(File.join(Segue::Paths.queue, next_name), "w") do |file|
+          file.puts track.to_yaml
+        end
+      end
+
+      private
+
+      # Millisecond timestamps collide when tracks are queued in quick
+      # succession, so add a zero padded sequence that keeps sorting stable.
+      def next_name
+        millis = (Time.now.to_f * 1000).to_i
+        sequence = 0
+        sequence += 1 while File.exist?(File.join(Segue::Paths.queue, name_for(millis, sequence)))
+        name_for(millis, sequence)
+      end
+
+      def name_for(millis, sequence)
+        format("%<millis>d-%<sequence>03d.yml", millis: millis, sequence: sequence)
+      end
+    end
+  end
+end

data/lib/segue/scrobbler.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "digest/md5"
+require "uri"
+require "cgi"
+require "rexml/document"
+require_relative "settings"
+
+module Segue
+  class Scrobbler
+    SCROBBLER_URL = "http://ws.audioscrobbler.com/2.0/"
+
+    class SubmissionError < RuntimeError
+    end
+
+    class SessionError < RuntimeError
+    end
+
+    def self.ask(prompt)
+      puts prompt
+      gets.chomp.strip
+    end
+
+    REQUIRED = %i[api_key secret user].freeze
+
+    def self.blank?(attribute)
+      (attribute || "").empty?
+    end
+
+    def self.load
+      conf = Segue::Settings.new("~/.lastfm.yml")
+      prompt_for_credentials(conf)
+      return nil if REQUIRED.any? { |key| blank?(conf[key]) }
+
+      scrobbler = new(conf[:api_key], conf[:secret], conf[:user], conf[:session])
+      conf[:session] ||= authorise(scrobbler)
+      return nil if blank?(conf[:session])
+
+      scrobbler
+    end
+
+    def self.prompt_for_credentials(conf)
+      conf[:api_key] = ask("What is the api key? ") if blank?(conf[:api_key])
+      conf[:secret] = ask("What is the secret? ") if blank?(conf[:secret])
+      conf[:user] = ask("What is your lastfm username? ") if blank?(conf[:user])
+    end
+
+    def self.authorise(scrobbler)
+      scrobbler.fetch_session_key do |url|
+        puts "A browser will now launch to allow to authorise this application to access your lastfm account"
+        `open '#{url}'`
+        puts "Press enter when you have authorised the application"
+        gets
+      end
+    end
+
+    def initialize(api_key, secret, user, session_key = nil)
+      @api_key     = api_key
+      @secret      = secret
+      @user        = user
+      @session_key = session_key
+    end
+
+    attr_reader :user, :api_key, :secret
+
+    def session_key
+      @session_key or raise SessionError, "The session key must be set or fetched"
+    end
+
+    def fetch_session_key
+      doc = lfm :get, "auth.gettoken"
+      request_token = doc.root.elements["token"].text
+      yield "http://www.last.fm/api/auth/?api_key=#{api_key}&token=#{request_token}"
+      doc = lfm :get, "auth.getsession", token: request_token
+      status = doc.root.attributes["status"]
+      raise SubmissionError, status unless status == "ok"
+
+      @session_key = doc.root.elements["session"].elements["key"].text
+    end
+
+    def with_profile_url
+      yield "http://www.last.fm/user/#{user}" if user
+    end
+
+    # http://www.last.fm/api/show?service=443
+    def scrobble(artist, title, params = {})
+      lfm_track "track.scrobble", artist, title, params
+    end
+
+    # See http://www.last.fm/api/show?service=454 for more details
+    def now_playing(artist, title, params = {})
+      lfm_track "track.updateNowPlaying", artist, title, params
+    end
+
+    # http://www.last.fm/api/show?service=260
+    def love(artist, title, params = {})
+      lfm_track "track.love", artist, title, params
+    end
+
+    private
+
+    def lfm_track(method, artist, title, params)
+      doc = lfm :post, method, params.merge(sk: session_key, artist: artist, track: title)
+      status = doc.root.attributes["status"]
+      raise SubmissionError, status unless status == "ok"
+    end
+
+    def lfm(get_or_post, method, parameters = {})
+      p = signed_parameters parameters.merge api_key: api_key, method: method
+      xml = send get_or_post, SCROBBLER_URL, p
+      REXML::Document.new xml
+    end
+
+    def get(url, parameters)
+      query_string = sort_parameters(parameters)
+                     .map { |k, v| "#{k}=#{CGI.escape(v)}" }
+                     .join("&")
+      Net::HTTP.get_response(URI.parse("#{url}?#{query_string}")).body
+    end
+
+    def post(url, parameters)
+      Net::HTTP.post_form(URI.parse(url), parameters).body
+    end
+
+    def signed_parameters(parameters)
+      sorted    = sort_parameters parameters
+      signature = Digest::MD5.hexdigest(sorted.join + secret)
+      parameters.merge api_sig: signature
+    end
+
+    def sort_parameters(parameters)
+      parameters.map { |k, v| [k.to_s, v.to_s] }.sort
+    end
+  end
+end

data/lib/segue/settings.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Segue
+  class Settings
+    attr_reader :path, :preferences
+
+    def initialize(path)
+      @path = File.expand_path(path)
+      FileUtils.mkdir_p File.dirname(@path)
+      @preferences = File.exist?(@path) ? YAML.load_file(@path) : {}
+    end
+
+    def [](key)
+      preferences[key]
+    end
+
+    def []=(key, value)
+      preferences[key] = value
+      persist
+    end
+
+    def persist
+      File.open(path, "w") { |f| f.puts preferences.to_yaml }
+    end
+  end
+end

data/lib/segue/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Segue
+  VERSION = "0.1.0"
+end