dtas 0.0.0

data/lib/dtas/process.rb

@@ -0,0 +1,87 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require 'shellwords'
+require 'io/wait'
+module DTAS::Process # :nodoc:
+  PIDS = {}
+
+  def self.reaper
+    begin
+      pid, status = Process.waitpid2(-1, Process::WNOHANG)
+      pid or return
+      obj = PIDS.delete(pid)
+      yield status, obj
+    rescue Errno::ECHILD
+      return
+    end while true
+  end
+
+  # a convienient way to display commands so it's easy to
+  # read, copy and paste to a shell
+  def xs(cmd)
+    cmd.map { |w| Shellwords.escape(w) }.join(' ')
+  end
+
+  # for long-running processes (sox/play/ecasound filters)
+  def dtas_spawn(env, cmd, opts)
+    opts = { close_others: true, pgroup: true }.merge!(opts)
+
+    # stringify env, integer values are easier to type unquoted as strings
+    env.each { |k,v| env[k] = v.to_s }
+
+    pid = begin
+      Process.spawn(env, cmd, opts)
+    rescue Errno::EINTR # Ruby bug?
+      retry
+    end
+    warn [ :spawn, pid, cmd ].inspect if $DEBUG
+    @spawn_at = Time.now.to_f
+    PIDS[pid] = self
+    pid
+  end
+
+  # this is like backtick, but takes an array instead of a string
+  # This will also raise on errors
+  def qx(cmd, opts = {})
+    r, w = IO.pipe
+    opts = opts.merge(out: w)
+    r.binmode
+    if err = opts[:err]
+      re, we = IO.pipe
+      re.binmode
+      opts[:err] = we
+    end
+    pid = begin
+      Process.spawn(*cmd, opts)
+    rescue Errno::EINTR # Ruby bug?
+      retry
+    end
+    w.close
+    if err
+      we.close
+      res = ""
+      want = { r => res, re => err }
+      begin
+        readable = IO.select(want.keys) or next
+        readable[0].each do |io|
+          bytes = io.nread
+          begin
+            want[io] << io.read_nonblock(bytes > 0 ? bytes : 11)
+          rescue Errno::EAGAIN
+            # spurious wakeup, bytes may be zero
+          rescue EOFError
+            want.delete(io)
+          end
+        end
+      end until want.empty?
+      re.close
+    else
+      res = r.read
+    end
+    r.close
+    _, status = Process.waitpid2(pid)
+    return res if status.success?
+    raise RuntimeError, "`#{xs(cmd)}' failed: #{status.inspect}"
+  end
+end

data/lib/dtas/replaygain.rb

@@ -0,0 +1,41 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+#
+# Represents ReplayGain metadata for a DTAS::Source
+# cleanup/validate values to prevent malicious files from making us
+# run arbitrary commands
+# *_peak values are 0..inf (1.0 being full scale, but >1 is possible
+# *_gain values are specified in dB
+
+class DTAS::ReplayGain # :nodoc:
+  ATTRS = %w(reference_loudness track_gain album_gain track_peak album_peak)
+  ATTRS.each { |a| attr_reader a }
+
+  def check_gain(val)
+    /([+-]?\d+(?:\.\d+)?)/ =~ val ? $1 : nil
+  end
+
+  def check_float(val)
+    /(\d+(?:\.\d+)?)/ =~ val ? $1 : nil
+  end
+
+  def initialize(comments)
+    comments or return
+
+    # the replaygain standard specifies 89.0 dB, but maybe some apps are
+    # different...
+    @reference_loudness =
+              check_gain(comments["REPLAYGAIN_REFERENCE_LOUDNESS"]) || "89.0"
+
+    @track_gain = check_gain(comments["REPLAYGAIN_TRACK_GAIN"])
+    @album_gain = check_gain(comments["REPLAYGAIN_ALBUM_GAIN"])
+    @track_peak = check_float(comments["REPLAYGAIN_TRACK_PEAK"])
+    @album_peak = check_float(comments["REPLAYGAIN_ALBUM_PEAK"])
+  end
+
+  def self.new(comments)
+    tmp = super
+    tmp.track_gain ? tmp : nil
+  end
+end

data/lib/dtas/rg_state.rb

@@ -0,0 +1,99 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+#
+# provides support for generating appropriate effects for ReplayGain
+# MAYBE: account for non-standard reference loudness (89.0 dB is standard)
+require_relative '../dtas'
+require_relative 'serialize'
+class DTAS::RGState # :nodoc:
+  include DTAS::Serialize
+
+  RG_MODE = {
+    # attribute name => method to use
+    "album_gain" => :rg_vol_gain,
+    "track_gain" => :rg_vol_gain,
+    "album_peak" => :rg_vol_norm,
+    "track_peak" => :rg_vol_norm,
+  }
+
+  RG_DEFAULT = {
+    # skip the effect if the adjustment is too small to be noticeable
+    "gain_threshold" => 0.00000001, # in dB
+    "norm_threshold" => 0.00000001,
+
+    "preamp" => 0, # no extra adjustment
+    # "mode" => "album_gain", # nil: off
+    "mode" => nil, # nil: off
+    "fallback_gain" => -6.0, # adjustment dB if necessary RG tag is missing
+    "fallback_track" => true,
+    "norm_level" => 1.0, # dBFS
+  }
+
+  SIVS = RG_DEFAULT.keys
+  SIVS.each { |iv| attr_accessor iv }
+
+  def initialize
+    RG_DEFAULT.each do |k,v|
+      instance_variable_set("@#{k}", v)
+    end
+  end
+
+  def self.load(hash)
+    rv = new
+    hash.each { |k,v| rv.__send__("#{k}=", v) } if hash
+    rv
+  end
+
+  def to_hash
+    ivars_to_hash(SIVS)
+  end
+
+  def to_hsh
+    # no point in dumping default values, it's just a waste of space
+    to_hash.delete_if { |k,v| RG_DEFAULT[k] == v }
+  end
+
+  # returns a dB argument to the "vol" effect, nil if nothing found
+  def rg_vol_gain(val)
+    val = val.to_f + @preamp
+    return if val.abs < @gain_threshold
+    sprintf('vol %0.8gdB', val)
+  end
+
+  # returns a linear argument to the "vol" effect
+  def rg_vol_norm(val)
+    diff = @norm_level - val.to_f
+    return if (@norm_level - diff).abs < @norm_threshold
+    diff += @norm_level
+    sprintf('vol %0.8g', diff)
+  end
+
+  # The ReplayGain fallback adjustment value (in dB), in case a file is
+  # missing ReplayGain tags.  This is useful to avoid damage to speakers,
+  # eardrums and amplifiers in case a file without then necessary ReplayGain
+  # tag slips into the queue
+  def rg_fallback_effect(reason)
+    @fallback_gain or return
+    warn(reason) if $DEBUG
+    "vol #{@fallback_gain + @preamp}dB"
+  end
+
+  # returns an array (for command-line argument) for the effect needed
+  # to apply ReplayGain
+  # this may return nil
+  def effect(source)
+    return unless @mode
+    rg = source.replaygain or
+      return rg_fallback_effect("ReplayGain tags missing")
+    val = rg.__send__(@mode)
+    if ! val && @fallback_track && @mode =~ /\Aalbum_(\w+)/
+      tag = "track_#$1"
+      val = rg.__send__(tag) or
+        return rg_fallback_effect("ReplayGain tag for #@mode missing")
+      warn("tag for #@mode missing, using #{tag}")
+    end
+    # this may be nil if the adjustment is too small:
+    __send__(RG_MODE[@mode], val)
+  end
+end

data/lib/dtas/serialize.rb

@@ -0,0 +1,9 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+module DTAS::Serialize # :nodoc:
+  def ivars_to_hash(ivars, rv = {})
+    ivars.each { |k| rv[k] = instance_variable_get("@#{k}") }
+    rv
+  end
+end

data/lib/dtas/sigevent.rb

@@ -0,0 +1,10 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+begin
+  raise LoadError, "no eventfd with _DTAS_POSIX" if ENV["_DTAS_POSIX"]
+  require 'sleepy_penguin'
+  require_relative 'sigevent/efd'
+rescue LoadError
+  require_relative 'sigevent/pipe'
+end

data/lib/dtas/sigevent/efd.rb

@@ -0,0 +1,20 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+class DTAS::Sigevent < SleepyPenguin::EventFD # :nodoc:
+  include SleepyPenguin
+
+  def self.new
+    super(0, EventFD::CLOEXEC)
+  end
+
+  def signal
+    incr(1)
+  end
+
+  def readable_iter
+    value(true)
+    yield self, nil # calls DTAS::Process.reaper
+    :wait_readable
+  end
+end

data/lib/dtas/sigevent/pipe.rb

@@ -0,0 +1,28 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+class DTAS::Sigevent # :nodoc:
+  attr_reader :to_io
+
+  def initialize
+    @to_io, @wr = IO.pipe
+  end
+
+  def signal
+    @wr.syswrite('.') rescue nil
+  end
+
+  def readable_iter
+    begin
+      @to_io.read_nonblock(11)
+      yield self, nil # calls DTAS::Process.reaper
+    rescue Errno::EAGAIN
+      return :wait_readable
+    end while true
+  end
+
+  def close
+    @to_io.close
+    @wr.close
+  end
+end

data/lib/dtas/sink.rb

@@ -0,0 +1,121 @@
+# -*- 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_relative '../dtas'
+require_relative 'pipe'
+require_relative 'process'
+require_relative 'command'
+require_relative 'format'
+require_relative 'serialize'
+require_relative 'writable_iter'
+
+# this is a sink (endpoint, audio enters but never leaves)
+class DTAS::Sink # :nodoc:
+  attr_accessor :prio    # any Integer
+  attr_accessor :active  # boolean
+  attr_accessor :name
+  attr_accessor :nonblock
+  attr_accessor :respawn
+
+  include DTAS::Command
+  include DTAS::Process
+  include DTAS::Serialize
+  include DTAS::WritableIter
+
+  SINK_DEFAULTS = COMMAND_DEFAULTS.merge({
+    "name" => nil, # order matters, this is first
+    "command" => "exec play -q $SOXFMT -",
+    "prio" => 0,
+    "nonblock" => false,
+    "pipe_size" => nil,
+    "active" => false,
+    "respawn" => false,
+  })
+
+  DEVFD_RE = %r{/dev/fd/([a-zA-Z]\w*)\b}
+
+  # order matters for Ruby 1.9+, this defines to_hsh serialization so we
+  # can make the state file human-friendly
+  SIVS = %w(name env command prio nonblock pipe_size active)
+
+  def initialize
+    command_init(SINK_DEFAULTS)
+    writable_iter_init
+    @sink = self
+  end
+
+  # allow things that look like audio device names ("hw:1,0" , "/dev/dsp")
+  # or variable names.
+  def valid_name?(s)
+    !!(s =~ %r{\A[\w:,/-]+\z})
+  end
+
+  def self.load(hash)
+    sink = new
+    return sink unless hash
+    (SIVS & hash.keys).each do |k|
+      sink.instance_variable_set("@#{k}", hash[k])
+    end
+    sink.valid_name?(sink.name) or raise ArgumentError, "invalid sink name"
+    sink
+  end
+
+  def parse(str)
+    inputs = {}
+    str.scan(DEVFD_RE) { |w| inputs[w[0]] = nil }
+    inputs
+  end
+
+  def on_death(status)
+    super
+  end
+
+  def spawn(format, opts = {})
+    raise "BUG: #{self.inspect}#spawn called twice" if @pid
+    rv = []
+
+    pclass = @nonblock ? DTAS::PipeNB : DTAS::Pipe
+
+    cmd = command_string
+    inputs = parse(cmd)
+
+    if inputs.empty?
+      # /dev/fd/* not specified in the command, assume one input for stdin
+      r, w = pclass.new
+      w.pipe_size = @pipe_size if @pipe_size
+      inputs[:in] = opts[:in] = r
+      w.sink = self
+      rv << w
+    else
+      # multiple inputs, fun!, we'll tee to them
+      inputs.each_key do |name|
+        r, w = pclass.new
+        w.pipe_size = @pipe_size if @pipe_size
+        inputs[name] = r
+        w.sink = self
+        rv << w
+      end
+      opts[:in] = "/dev/null"
+
+      # map to real /dev/fd/* values and setup proper redirects
+      cmd = cmd.gsub(DEVFD_RE) do
+        read_fd = inputs[$1].fileno
+        opts[read_fd] = read_fd # do not close-on-exec
+        "/dev/fd/#{read_fd}"
+      end
+    end
+
+    @pid = dtas_spawn(format.to_env.merge!(@env), cmd, opts)
+    inputs.each_value { |rpipe| rpipe.close }
+    rv
+  end
+
+  def to_hash
+    ivars_to_hash(SIVS)
+  end
+
+  def to_hsh
+    to_hash.delete_if { |k,v| v == SINK_DEFAULTS[k] }
+  end
+end

data/lib/dtas/source.rb

@@ -0,0 +1,147 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require_relative '../dtas'
+require_relative 'command'
+require_relative 'format'
+require_relative 'replaygain'
+require_relative 'process'
+require_relative 'serialize'
+
+# this is usually one input file
+class DTAS::Source # :nodoc:
+  attr_reader :infile
+  attr_reader :offset
+  require_relative 'source/common'
+  require_relative 'source/mp3'
+
+  include DTAS::Command
+  include DTAS::Process
+  include DTAS::Source::Common
+  include DTAS::Source::Mp3
+
+  SOURCE_DEFAULTS = COMMAND_DEFAULTS.merge(
+    "command" => 'exec sox "$INFILE" $SOXFMT - $TRIMFX $RGFX',
+    "comments" => nil,
+  )
+
+  SIVS = %w(infile comments command env)
+
+  def initialize(infile, offset = nil)
+    command_init(SOURCE_DEFAULTS)
+    @format = nil
+    @infile = infile
+    @offset = offset
+    @comments = nil
+    @samples = nil
+  end
+
+  # this exists mainly to make the mpris interface easier, but it's not
+  # necessary, the mpris interface also knows the sample rate
+  def offset_us
+    (offset_samples / format.rate.to_f) * 1000000
+  end
+
+  # returns any offset in samples (relative to the original source file),
+  # likely zero unless seek was used
+  def offset_samples
+    return 0 unless @offset
+    case @offset
+    when /\A\d+s\z/
+      @offset.to_i
+    else
+      format.hhmmss_to_samples(@offset)
+    end
+  end
+
+  def precision
+    qx(%W(soxi -p #@infile), err: "/dev/null").to_i # sox.git f4562efd0aa3
+  rescue # fallback to parsing the whole output
+    s = qx(%W(soxi #@infile), err: "/dev/null")
+    s =~ /Precision\s+:\s*(\d+)-bit/
+    v = $1.to_i
+    return v if v > 0
+    raise TypeError, "could not determine precision for #@infile"
+  end
+
+  def format
+    @format ||= begin
+      fmt = DTAS::Format.new
+      fmt.from_file(@infile)
+      fmt.bits ||= precision
+      fmt
+    end
+  end
+
+  # A user may be downloading the file and start playing
+  # it before the download completes, this refreshes
+  def samples!
+    @samples = nil
+    samples
+  end
+
+  # This is the number of samples according to the samples in the source
+  # file itself, not the decoded output
+  def samples
+    @samples ||= qx(%W(soxi -s #@infile)).to_i
+  rescue => e
+    warn e.message
+    0
+  end
+
+  # just run soxi -a
+  def __load_comments
+    tmp = {}
+    case @infile
+    when String
+      err = ""
+      cmd = %W(soxi -a #@infile)
+      begin
+        qx(cmd, err: err).split(/\n/).each do |line|
+          key, value = line.split(/=/, 2)
+          key && value or next
+          # TODO: multi-line/multi-value/repeated tags
+          tmp[key.upcase] = value
+        end
+      rescue => e
+        if /FAIL formats: no handler for file extension/ =~ err
+          warn("#{xs(cmd)}: #{err}")
+        else
+          warn("#{e.message} (#{e.class})")
+        end
+        # TODO: fallbacks
+      end
+    end
+    tmp
+  end
+
+  def comments
+    @comments ||= __load_comments
+  end
+
+  def replaygain
+    DTAS::ReplayGain.new(comments) || DTAS::ReplayGain.new(mp3gain_comments)
+  end
+
+  def spawn(format, rg_state, opts)
+    raise "BUG: #{self.inspect}#spawn called twice" if @to_io
+    e = format.to_env
+    e["INFILE"] = @infile
+
+    # make sure these are visible to the "current" command...
+    @env["TRIMFX"] = @offset ? "trim #@offset" : nil
+    @env["RGFX"] = rg_state.effect(self) || nil
+
+    @pid = dtas_spawn(e.merge!(@env), command_string, opts)
+  end
+
+  def to_hsh
+    to_hash.delete_if { |k,v| v == SOURCE_DEFAULTS[k] }
+  end
+
+  def to_hash
+    rv = ivars_to_hash(SIVS)
+    rv["samples"] = samples
+    rv
+  end
+end