dtas 0.0.0 → 0.1.I

data/lib/dtas/process.rb

@@ -3,6 +3,7 @@
 # License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
 require 'shellwords'
 require 'io/wait'
+require_relative '../dtas'
 module DTAS::Process # :nodoc:
   PIDS = {}
 
@@ -17,12 +18,6 @@ module DTAS::Process # :nodoc:
     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)
@@ -43,31 +38,35 @@ module DTAS::Process # :nodoc:
 
   # this is like backtick, but takes an array instead of a string
   # This will also raise on errors
-  def qx(cmd, opts = {})
+  def qx(env, cmd = {}, opts = {})
+    unless Hash === env
+      cmd, opts = env, cmd
+      env = {}
+    end
     r, w = IO.pipe
     opts = opts.merge(out: w)
     r.binmode
-    if err = opts[:err]
+    no_raise = opts.delete(:no_raise)
+    if err_str = opts.delete(:err_str)
       re, we = IO.pipe
       re.binmode
       opts[:err] = we
     end
     pid = begin
-      Process.spawn(*cmd, opts)
+      Process.spawn(env, *cmd, opts)
     rescue Errno::EINTR # Ruby bug?
       retry
     end
     w.close
-    if err
+    if err_str
       we.close
       res = ""
-      want = { r => res, re => err }
+      want = { r => res, re => err_str }
       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)
+            want[io] << io.read_nonblock(2000)
           rescue Errno::EAGAIN
             # spurious wakeup, bytes may be zero
           rescue EOFError
@@ -77,11 +76,13 @@ module DTAS::Process # :nodoc:
       end until want.empty?
       re.close
     else
-      res = r.read
+      res = r.read # read until EOF
     end
     r.close
     _, status = Process.waitpid2(pid)
     return res if status.success?
-    raise RuntimeError, "`#{xs(cmd)}' failed: #{status.inspect}"
+    return status if no_raise
+    raise RuntimeError,
+          "`#{Shellwords.join(Array(cmd))}' failed: #{status.inspect}"
   end
 end

data/lib/dtas/replaygain.rb

@@ -10,7 +10,11 @@
 
 class DTAS::ReplayGain # :nodoc:
   ATTRS = %w(reference_loudness track_gain album_gain track_peak album_peak)
-  ATTRS.each { |a| attr_reader a }
+  ENV_ATTRS = {}
+  ATTRS.each do |a|
+    attr_reader a
+    ENV_ATTRS["REPLAYGAIN_#{a.upcase}"] = a
+  end
 
   def check_gain(val)
     /([+-]?\d+(?:\.\d+)?)/ =~ val ? $1 : nil
@@ -20,13 +24,25 @@ class DTAS::ReplayGain # :nodoc:
     /(\d+(?:\.\d+)?)/ =~ val ? $1 : nil
   end
 
+  # note: this strips the "dB" suffix, but that should be easier for apps
+  # to deal with anyways...
+  def to_env
+    rv = {}
+    # this will cause nil to be set if some envs are missing, this causes
+    # Process.spawn to unset the environment if it was previously set
+    # (leaked from some other process)
+    ENV_ATTRS.each do |env_name, attr_name|
+      rv[env_name] = __send__(attr_name)
+    end
+    rv
+  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"
+    @reference_loudness = check_gain(comments["REPLAYGAIN_REFERENCE_LOUDNESS"])
 
     @track_gain = check_gain(comments["REPLAYGAIN_TRACK_GAIN"])
     @album_gain = check_gain(comments["REPLAYGAIN_ALBUM_GAIN"])

data/lib/dtas/sink.rb

@@ -15,8 +15,8 @@ class DTAS::Sink # :nodoc:
   attr_accessor :prio    # any Integer
   attr_accessor :active  # boolean
   attr_accessor :name
+  attr_accessor :pipe_size
   attr_accessor :nonblock
-  attr_accessor :respawn
 
   include DTAS::Command
   include DTAS::Process
@@ -30,7 +30,6 @@ class DTAS::Sink # :nodoc:
     "nonblock" => false,
     "pipe_size" => nil,
     "active" => false,
-    "respawn" => false,
   })
 
   DEVFD_RE = %r{/dev/fd/([a-zA-Z]\w*)\b}

data/lib/dtas/source.rb

@@ -2,146 +2,6 @@
 # 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
+module DTAS::Source # :nodoc:
 end

data/lib/dtas/source/av.rb

@@ -0,0 +1,29 @@
+# -*- 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 'av_ff_common'
+
+# this is usually one input file
+class DTAS::Source::Av # :nodoc:
+  include DTAS::Source::AvFfCommon
+
+  AV_DEFAULTS = COMMAND_DEFAULTS.merge(
+    "command" =>
+      'avconv -v error $SSPOS -i "$INFILE" $AMAP -f sox - |' \
+      'sox -p $SOXFMT - $RGFX',
+
+    # this is above ffmpeg because this av is the Debian default and
+    # it's easier for me to test av than ff
+    "tryorder" => 1,
+  )
+
+  def initialize
+    command_init(AV_DEFAULTS)
+    @av_ff_probe = "avprobe"
+  end
+
+  def source_defaults
+    AV_DEFAULTS
+  end
+end

data/lib/dtas/source/av_ff_common.rb

@@ -0,0 +1,127 @@
+# -*- 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 '../source'
+require_relative '../replaygain'
+require_relative 'file'
+
+# Common code for libav (avconv/avprobe) and ffmpeg (and ffprobe)
+# TODO: newer versions of both *probes support JSON, which will be easier to
+# parse.  However, the packaged libav version in Debian 7.0 does not
+# support JSON, so we have an ugly parser...
+module DTAS::Source::AvFfCommon # :nodoc:
+  include DTAS::Source::File
+  AStream = Struct.new(:duration, :channels, :rate)
+  AV_FF_TRYORDER = 1
+
+  attr_reader :precision # always 32
+  attr_reader :format
+
+  def try(infile, offset = nil)
+    rv = source_file_dup(infile, offset)
+    rv.av_ff_ok? or return
+    rv
+  end
+
+  def av_ff_ok?
+    @duration = nil
+    @format = DTAS::Format.new
+    @format.bits = 32 # always, since we still use the "sox" format
+    @comments = {}
+    @astreams = []
+    cmd = %W(#@av_ff_probe -show_streams -show_format #@infile)
+    err = ""
+    s = qx(@env, cmd, err_str: err, no_raise: true)
+    return false if Process::Status === s
+    return false if err =~ /Unable to find a suitable output format for/
+    s.scan(%r{^\[STREAM\]\n(.*?)\n\[/STREAM\]\n}m) do |_|
+      stream = $1
+      if stream =~ /^codec_type=audio$/
+        as = AStream.new
+        index = nil
+        stream =~ /^index=(\d+)\s*$/m and index = $1.to_i
+        stream =~ /^duration=([\d\.]+)\s*$/m and as.duration = $1.to_f
+        stream =~ /^channels=(\d)\s*$/m and as.channels = $1.to_i
+        stream =~ /^sample_rate=([\d\.]+)\s*$/m and as.rate = $1.to_i
+        index or raise "BUG: no audio index from #{Shellwords.join(cmd)}"
+
+        # some streams have zero channels
+        @astreams[index] = as if as.channels > 0 && as.rate > 0
+      end
+    end
+    s.scan(%r{^\[FORMAT\]\n(.*?)\n\[/FORMAT\]\n}m) do |_|
+      f = $1
+      f =~ /^duration=([\d\.]+)\s*$/m and @duration = $1.to_f
+      # TODO: multi-line/multi-value/repeated tags
+      f.gsub!(/^TAG:([^=]+)=(.*)$/i) { |_| @comments[$1.upcase] = $2 }
+    end
+    ! @astreams.empty?
+  end
+
+  def sspos(offset)
+    offset =~ /\A(\d+)s\z/ or return "-ss #{offset}"
+    samples = $1.to_f
+    sprintf("-ss %0.9g", samples / @format.rate)
+  end
+
+  def select_astream(as)
+    @format.channels = as.channels
+    @format.rate = as.rate
+
+    # favor the duration of the stream we're playing instead of
+    # duration we got from [FORMAT].  However, some streams may not have
+    # a duration and only have it in [FORMAT]
+    @duration = as.duration if as.duration
+  end
+
+  def amap_fallback
+    @astreams.each_with_index do |as, index|
+      as or next
+      select_astream(as)
+      warn "no suitable audio stream in #@infile, trying stream=#{index}"
+      return "-map 0:#{i}"
+    end
+    raise "BUG: no audio stream in #@infile"
+  end
+
+  def spawn(player_format, rg_state, opts)
+    raise "BUG: #{self.inspect}#spawn called twice" if @to_io
+    amap = nil
+
+    # try to find an audio stream which matches our channel count
+    # we need to set @format for sspos() down below
+    @astreams.each_with_index do |as, i|
+      if as && as.channels == player_format.channels
+        select_astream(as)
+        amap = "-map 0:#{i}"
+      end
+    end
+
+    # fall back to the first audio stream
+    # we must call select_astream before sspos
+    amap ||= amap_fallback
+
+    e = @env.merge!(player_format.to_env)
+
+    # make sure these are visible to the source command...
+    e["INFILE"] = @infile
+    e["AMAP"] = amap
+    e["SSPOS"] = @offset ? sspos(@offset) : nil
+    e["RGFX"] = rg_state.effect(self) || nil
+    e.merge!(@rg.to_env) if @rg
+
+    @pid = dtas_spawn(e, command_string, opts)
+  end
+
+  # This is the number of samples according to the samples in the source
+  # file itself, not the decoded output
+  def samples
+    @samples ||= (@duration * @format.rate).round
+  end
+
+  def to_hsh
+    sd = source_defaults
+    to_hash.delete_if { |k,v| v == sd[k] }
+  end
+end

data/lib/dtas/source/{command.rb → cmd.rb}

@@ -6,7 +6,7 @@ require_relative '../source'
 require_relative '../command'
 require_relative '../serialize'
 
-class DTAS::Source::Command # :nodoc:
+class DTAS::Source::Cmd # :nodoc:
   require_relative '../source/common'
 
   include DTAS::Command