dtas 0.0.0

data/lib/dtas/command.rb

@@ -0,0 +1,43 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+# common code for wrapping SoX/ecasound/... commands
+require_relative 'serialize'
+require 'shellwords'
+
+module DTAS::Command # :nodoc:
+  include DTAS::Serialize
+  attr_reader :pid
+  attr_reader :to_io
+  attr_accessor :command
+  attr_accessor :env
+  attr_accessor :spawn_at
+
+  COMMAND_DEFAULTS = {
+    "env" => {},
+    "command" => nil,
+  }
+
+  def command_init(defaults = {})
+    @pid = nil
+    @to_io = nil
+    @spawn_at = nil
+    COMMAND_DEFAULTS.merge(defaults).each do |k,v|
+      v = v.dup if Hash === v || Array === v
+      instance_variable_set("@#{k}", v)
+    end
+  end
+
+  def kill(sig = :TERM)
+    # always kill the pgroup since we run subcommands in their own shell
+    Process.kill(sig, -@pid)
+  end
+
+  def on_death(status)
+    @pid = nil
+  end
+
+  def command_string
+    @command
+  end
+end

data/lib/dtas/compat_onenine.rb

@@ -0,0 +1,18 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+
+# Make Ruby 1.9.3 look like Ruby 2.0.0 to us
+# This exists for Debian wheezy users using the stock Ruby 1.9.3 install.
+# We'll drop this interface when Debian wheezy (7.0) becomes unsupported.
+class String
+  def b # :nodoc:
+    dup.force_encoding(Encoding::BINARY)
+  end
+end unless String.method_defined?(:b)
+
+def IO
+  def self.pipe # :nodoc:
+    super.map! { |io| io.close_on_exec = true; io }
+  end
+end if RUBY_VERSION.to_f <= 1.9

data/lib/dtas/disclaimer.rb

@@ -0,0 +1,18 @@
+# -*- encoding: binary -*-
+# :enddoc:
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+DTAS_DISCLAIMER = <<EOF
+# WARNING!
+#
+# Ignorant or improper use of #$0 may lead to
+# data loss, hearing loss, and damage to audio equipment.
+#
+# Please read and understand the documentation of all commands you
+# attempt to configure.
+#
+# #$0 will never prevent you from doing stupid things.
+#
+# There is no warranty, the developers of #$0
+# are not responsible for your actions.
+EOF

data/lib/dtas/format.rb

@@ -0,0 +1,151 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+# class represents an audio format (type/bits/channels/sample rate/...)
+require_relative '../dtas'
+require_relative 'process'
+require_relative 'serialize'
+
+class DTAS::Format # :nodoc:
+  include DTAS::Process
+  include DTAS::Serialize
+  NATIVE_ENDIAN = [1].pack("l") == [1].pack("l>") ? "big" : "little"
+
+  attr_accessor :type # s32, f32, f64 ... any point in others?
+  attr_accessor :channels # 1..666
+  attr_accessor :rate     # 44100, 48000, 88200, 96000, 176400, 192000 ...
+  attr_accessor :bits # only set for playback on 16-bit DACs
+  attr_accessor :endian
+
+  FORMAT_DEFAULTS = {
+    "type" => "s32",
+    "channels" => 2,
+    "rate" => 44100,
+    "bits" => nil,   # default: implied from type
+    "endian" => nil, # unspecified
+  }
+  SIVS = FORMAT_DEFAULTS.keys
+
+  def self.load(hash)
+    fmt = new
+    return fmt unless hash
+    (SIVS & hash.keys).each do |k|
+      fmt.instance_variable_set("@#{k}", hash[k])
+    end
+    fmt
+  end
+
+  def initialize
+    FORMAT_DEFAULTS.each do |k,v|
+      instance_variable_set("@#{k}", v)
+    end
+  end
+
+  def to_sox_arg
+   rv = %W(-t#@type -c#@channels -r#@rate)
+   rv.concat(%W(-b#@bits)) if @bits # needed for play(1) to 16-bit DACs
+   rv
+  end
+
+  # returns 'be' or 'le' depending on endianess
+  def endian2
+    case e = @endian || NATIVE_ENDIAN
+    when "big"
+      "be"
+    when "little"
+      "le"
+    else
+      raise"unsupported endian=#{e}"
+    end
+  end
+
+  def to_eca_arg
+    %W(-f #{@type}_#{endian2},#@channels,#@rate)
+  end
+
+  def inspect
+    "<#{self.class}(#{xs(to_sox_arg)})>"
+  end
+
+  def to_hsh
+    to_hash.delete_if { |k,v| v == FORMAT_DEFAULTS[k] }
+  end
+
+  def to_hash
+    ivars_to_hash(SIVS)
+  end
+
+  def from_file(path)
+    @channels = qx(%W(soxi -c #{path})).to_i
+    @type = qx(%W(soxi -t #{path})).strip
+    @rate = qx(%W(soxi -r #{path})).to_i
+    # we don't need to care for bits, do we?
+  end
+
+  # for the _decoded_ output
+  def bits_per_sample
+    return @bits if @bits
+    /\A[fst](8|16|24|32|64)\z/ =~ @type or
+      raise TypeError, "invalid type=#@type (must be s32/f32/f64)"
+    $1.to_i
+  end
+
+  def bytes_per_sample
+    bits_per_sample / 8
+  end
+
+  def to_env
+    rv = {
+      "SOX_FILETYPE" => @type,
+      "CHANNELS" => @channels.to_s,
+      "RATE" => @rate.to_s,
+      "ENDIAN" => @endian || NATIVE_ENDIAN,
+      "SOXFMT" => to_sox_arg.join(' '),
+      "ECAFMT" => to_eca_arg.join(' '),
+      "ENDIAN2" => endian2,
+    }
+    begin # don't set these if we can't get them, SOX_FILETYPE may be enough
+      rv["BITS_PER_SAMPLE"] = bits_per_sample.to_s
+    rescue TypeError
+    end
+    rv
+  end
+
+  def bytes_to_samples(bytes)
+    bytes / bytes_per_sample / @channels
+  end
+
+  def bytes_to_time(bytes)
+    Time.at(bytes_to_samples(bytes) / @rate.to_f)
+  end
+
+  def valid_type?(type)
+    !!(type =~ %r{\A[us](?:8|16|24|32)\z} || type =~ %r{\Af?:(32|64)})
+  end
+
+  def valid_endian?(endian)
+    !!(endian =~ %r{\A(?:big|little|swap)\z})
+  end
+
+  # HH:MM:SS.frac (don't bother with more complex times, too much code)
+  # part of me wants to drop this feature from playq, feels like bloat...
+  def hhmmss_to_samples(hhmmss)
+    time = hhmmss.dup
+    rv = 0
+    if time.sub!(/\.(\d+)\z/, "")
+      # convert fractional second to sample count:
+      rv = ("0.#$1".to_f * @rate).to_i
+    end
+
+    # deal with HH:MM:SS
+    t = time.split(/:/)
+    raise ArgumentError, "Bad time format: #{hhmmss}" if t.size > 3
+
+    mult = 1
+    while part = t.pop
+      rv += part.to_i * mult * @rate
+      mult *= 60
+    end
+    rv
+  end
+end

data/lib/dtas/pipe.rb

@@ -0,0 +1,39 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+begin
+  require 'io/splice'
+rescue LoadError
+end
+require_relative '../dtas'
+require_relative 'writable_iter'
+
+class DTAS::Pipe < IO # :nodoc:
+  include DTAS::WritableIter
+  attr_accessor :sink
+
+  def self.new
+    _, w = rv = pipe
+    w.writable_iter_init
+    rv
+  end
+
+  # create no-op methods for non-Linux
+  unless method_defined?(:pipe_size=)
+    def pipe_size=(_)
+    end
+
+    def pipe_size
+    end
+  end
+end
+
+# for non-blocking sinks, this avoids extra fcntl(..., F_GETFL) syscalls
+# We don't need fcntl at all for splice/tee in Linux
+# For non-Linux, we write_nonblock/read_nonblock already call fcntl()
+# behind our backs, so there's no need to repeat it.
+class DTAS::PipeNB < DTAS::Pipe # :nodoc:
+  def nonblock?
+    true
+  end
+end

data/lib/dtas/player.rb

@@ -0,0 +1,393 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require 'yaml'
+require 'shellwords'
+require_relative '../dtas'
+require_relative 'source'
+require_relative 'source/command'
+require_relative 'sink'
+require_relative 'unix_server'
+require_relative 'buffer'
+require_relative 'sigevent'
+require_relative 'rg_state'
+require_relative 'state_file'
+
+class DTAS::Player # :nodoc:
+  require_relative 'player/client_handler'
+  include DTAS::Player::ClientHandler
+  attr_accessor :state_file
+  attr_accessor :socket
+  attr_reader :sinks
+
+  def initialize
+    @state_file = nil
+    @socket = nil
+    @srv = nil
+    @queue = [] # sources
+    @paused = false
+    @format = DTAS::Format.new
+    @srccmd = nil
+    @srcenv = {}
+
+    @sinks = {} # { user-defined name => sink }
+    @targets = [] # order matters
+    @rg = DTAS::RGState.new
+
+    # sits in between shared effects (if any) and sinks
+    @sink_buf = DTAS::Buffer.new
+    @current = nil
+    @watchers = {}
+  end
+
+  def echo(msg)
+    msg = Shellwords.join(msg) if Array === msg
+    @watchers.delete_if do |io, _|
+      if io.closed?
+        true
+      else
+        case io.emit(msg)
+        when :wait_readable, :wait_writable
+          false
+        else
+          true
+        end
+      end
+    end
+    $stdout.write(msg << "\n")
+  end
+
+  def to_hsh
+    rv = {}
+    rv["socket"] = @socket
+    rv["paused"] = @paused if @paused
+    src = rv["source"] = {}
+    src["command"] = @srccmd if @srccmd
+    src["env"] = @srcenv if @srcenv.size > 0
+
+    # Arrays
+    rv["queue"] = @queue
+
+    %w(rg sink_buf format).each do |k|
+      rv[k] = instance_variable_get("@#{k}").to_hsh
+    end
+
+    # no empty hashes or arrays
+    rv.delete_if do |k,v|
+      case v
+      when Hash, Array
+        v.empty?
+      else
+        false
+      end
+    end
+
+    unless @sinks.empty?
+      sinks = rv["sinks"] = []
+      # sort sinks by name for human viewability
+      @sinks.keys.sort.each do |name|
+        sinks << @sinks[name].to_hsh
+      end
+    end
+
+    rv
+  end
+
+  def self.load(hash)
+    rv = new
+    rv.instance_eval do
+      @rg = DTAS::RGState.load(hash["rg"])
+      if v = hash["sink_buf"]
+        v = v["buffer_size"]
+        @sink_buf.buffer_size = v
+      end
+      %w(socket queue paused).each do |k|
+        v = hash[k] or next
+        instance_variable_set("@#{k}", v)
+      end
+      if v = hash["source"]
+        @srccmd = v["command"]
+        e = v["env"] and @srcenv = e
+      end
+
+      if v = hash["format"]
+        @format = DTAS::Format.load(v)
+      end
+
+      if sinks = hash["sinks"]
+        sinks.each do |sink_hsh|
+          sink = DTAS::Sink.load(sink_hsh)
+          @sinks[sink.name] = sink
+        end
+      end
+    end
+    rv
+  end
+
+  def enq_handler(io, msg)
+    # check @queue[0] in case we have no sinks
+    if @current || @queue[0] || @paused
+      @queue << msg
+    else
+      next_source(msg)
+    end
+    io.emit("OK")
+  end
+
+  def do_enq_head(io, msg)
+    # check @queue[0] in case we have no sinks
+    if @current || @queue[0] || @paused
+      @queue.unshift(msg)
+    else
+      next_source(msg)
+    end
+    io.emit("OK")
+  end
+
+  # yielded from readable_iter
+  def client_iter(io, msg)
+    msg = Shellwords.split(msg)
+    command = msg.shift
+    case command
+    when "enq"
+      enq_handler(io, msg[0])
+    when "enq-head"
+      do_enq_head(io, msg)
+    when "enq-cmd"
+      enq_handler(io, { "command" => msg[0]})
+    when "pause", "play", "play_pause"
+      play_pause_handler(io, command)
+    when "seek"
+      do_seek(io, msg[0])
+    when "clear"
+      @queue.clear
+      echo("clear")
+      io.emit("OK")
+    when "rg"
+      rg_handler(io, msg)
+    when "skip"
+      skip_handler(io, msg)
+    when "sink"
+      sink_handler(io, msg)
+    when "current"
+      current_handler(io, msg)
+    when "watch"
+      @watchers[io] = true
+      io.emit("OK")
+    when "format"
+      format_handler(io, msg)
+    when "env"
+      env_handler(io, msg)
+    when "restart"
+      restart_pipeline
+      io.emit("OK")
+    when "source"
+      source_handler(io, msg)
+    when "cd"
+      chdir_handler(io, msg)
+    when "pwd"
+      io.emit(Dir.pwd)
+    end
+  end
+
+  def event_loop_iter
+    @srv.run_once do |io, msg| # readability handler, request/response
+      case io
+      when @sink_buf
+        sink_iter
+      when DTAS::UNIXAccepted
+        client_iter(io, msg)
+      when DTAS::Sigevent # signal received
+        reap_iter
+      else
+        raise "BUG: unknown event: #{io.class} #{io.inspect} #{msg.inspect}"
+      end
+    end
+  end
+
+  def reap_iter
+    DTAS::Process.reaper do |status, obj|
+      warn [ :reap, obj, status ].inspect if $DEBUG
+      obj.on_death(status) if obj.respond_to?(:on_death)
+      case obj
+      when @current
+        next_source(@paused ? nil : @queue.shift)
+      when DTAS::Sink # on unexpected sink death
+        sink_death(obj, status)
+      end
+    end
+    :wait_readable
+  end
+
+  def sink_death(sink, status)
+    deleted = []
+    @targets.delete_if do |t|
+      if t.sink == sink
+        deleted << t
+      else
+        false
+      end
+    end
+
+    if deleted[0]
+      warn("#{sink.name} died unexpectedly: #{status.inspect}")
+      deleted.each { |t| drop_target(t) }
+      __current_drop unless @targets[0]
+    end
+
+    return unless sink.active
+
+    if @queue[0] && !@paused
+      # we get here if source/sinks are all killed in restart_pipeline
+      __sink_activate(sink)
+      next_source(@queue.shift)
+    elsif sink.respawn
+      __sink_activate(sink) if @current
+    end
+  ensure
+    sink.respawn = false
+  end
+
+  # returns a wait_ctl arg for self
+  def broadcast_iter(buf, targets)
+    case rv = buf.broadcast(targets)
+    when Array # array of blocked sinks
+      # have sinks wake up the this buffer when they're writable
+      trade_ctl = proc { @srv.wait_ctl(buf, :wait_readable) }
+      rv.each do |dst|
+        dst.on_writable = trade_ctl
+        @srv.wait_ctl(dst, :wait_writable)
+      end
+
+      # this @sink_buf hibernates until trade_ctl is called
+      # via DTAS::Sink#writable_iter
+      :ignore
+    else # :wait_readable or nil
+      rv
+    end
+  end
+
+  def bind
+    @srv = DTAS::UNIXServer.new(@socket)
+  end
+
+  # only used on new installations where no sink exists
+  def create_default_sink
+    return unless @sinks.empty?
+    s = DTAS::Sink.new
+    s.name = "default"
+    s.active = true
+    @sinks[s.name] = s
+  end
+
+  # called when the player is leaving idle state
+  def spawn_sinks(source_spec)
+    return true if @targets[0]
+    @sinks.each_value do |sink|
+      sink.active or next
+      next if sink.pid
+      @targets.concat(sink.spawn(@format))
+    end
+    if @targets[0]
+      @targets.sort_by! { |t| t.sink.prio }
+      true
+    else
+      # fail, no active sink
+      @queue.unshift(source_spec)
+      false
+    end
+  end
+
+  def next_source(source_spec)
+    @current = nil
+    if source_spec
+      # restart sinks iff we were idle
+      spawn_sinks(source_spec) or return
+
+      case source_spec
+      when String
+        @current = DTAS::Source.new(source_spec)
+        echo(%W(file #{@current.infile}))
+      when Array
+        @current = DTAS::Source.new(*source_spec)
+        echo(%W(file #{@current.infile} #{@current.offset_samples}s))
+      else
+        @current = DTAS::Source::Command.new(source_spec["command"])
+        echo(%W(command #{@current.command_string}))
+      end
+
+      if DTAS::Source === @current
+        @current.command = @srccmd if @srccmd
+        @current.env = @srcenv.dup unless @srcenv.empty?
+      end
+
+      dst = @sink_buf
+      @current.dst_assoc(dst)
+      @current.spawn(@format, @rg, out: dst.wr, in: "/dev/null")
+      @srv.wait_ctl(dst, :wait_readable)
+    else
+      stop_sinks if @sink_buf.inflight == 0
+      echo "idle"
+    end
+  end
+
+  def drop_target(target)
+    @srv.wait_ctl(target, :delete)
+    target.close
+  end
+
+  def stop_sinks
+    @targets.each { |t| drop_target(t) }.clear
+  end
+
+  # only call on unrecoverable errors (or "skip")
+  def __current_drop(src = @current)
+    __buf_reset(src.dst) if src && src.pid
+  end
+
+  # pull data from sink_buf into @targets, source feeds into sink_buf
+  def sink_iter
+    wait_iter = broadcast_iter(@sink_buf, @targets)
+    __current_drop if nil == wait_iter # sink error, stop source
+    return wait_iter if @current
+
+    # no source left to feed sink_buf, drain the remaining data
+    sink_bytes = @sink_buf.inflight
+    if sink_bytes > 0
+      return wait_iter if @targets[0] # play what is leftover
+
+      # discard the buffer if no sinks
+      @sink_buf.discard(sink_bytes)
+    end
+
+    # nothing left inflight, stop the sinks until we have a source
+    stop_sinks
+    :ignore
+  end
+
+  # the main loop
+  def run
+    sev = DTAS::Sigevent.new
+    @srv.wait_ctl(sev, :wait_readable)
+    old_chld = trap(:CHLD) { sev.signal }
+    create_default_sink
+    next_source(@paused ? nil : @queue.shift)
+    begin
+      event_loop_iter
+    rescue => e # just in case...
+      warn "E: #{e.message} (#{e.class})"
+      e.backtrace.each { |l| warn l }
+    end while true
+  ensure
+    __current_requeue
+    trap(:CHLD, old_chld)
+    sev.close if sev
+    # for state file
+  end
+
+  def close
+    @srv = @srv.close if @srv
+    @sink_buf.close!
+    @state_file.dump(self, true) if @state_file
+  end
+end