dtas 0.11.0 → 0.12.0

data/lib/dtas/process.rb

@@ -1,8 +1,10 @@
 # Copyright (C) 2013-2015 all contributors <dtas-all@nongnu.org>
 # License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
 require 'io/wait'
+require 'shellwords'
 require_relative '../dtas'
 require_relative 'xs'
+require_relative 'nonblock'
 
 # process management helpers
 module DTAS::Process # :nodoc:
@@ -23,6 +25,7 @@ def self.reaper
 
   # expand common shell constructs based on environment variables
   # this is order-dependent, but Ruby 1.9+ hashes are already order-dependent
+  # This recurses
   def env_expand(env, opts)
     env = env.dup
     if false == opts.delete(:expand)
@@ -31,19 +34,40 @@ def env_expand(env, opts)
       end
     else
       env.each do |key, val|
-        case val
-        when Numeric # stringify numeric values to simplify users' lives
-          env[key] = val.to_s
-        when /[\`\$]/ # perform variable/command expansion
-          tmp = env.dup
-          tmp.delete(key)
-          val = qx(tmp, "echo #{val}", expand: false)
-          env[key] = val.chomp
+        case val = env_expand_i(env, key, val)
+        when Array
+          val.flatten!
+          env[key] = Shellwords.join(val)
         end
       end
     end
   end
 
+  def env_expand_i(env, key, val)
+    case val
+    when Numeric # stringify numeric values to simplify users' lives
+      env[key] = val.to_s
+    when /[\`\$]/ # perform variable/command expansion
+      tmp = env.dup
+      tmp.delete(key)
+      tmp.each do |k,v|
+        # best effort, this can get wonky
+        tmp[k] = Shellwords.join(v.flatten) if Array === v
+      end
+      val = qx(tmp, "echo #{val}", expand: false)
+      env[key] = val.chomp
+    when Array
+      env[key] = env_expand_ary(env, key, val)
+    else
+      val
+    end
+  end
+
+  # warning, recursion:
+  def env_expand_ary(env, key, val)
+    val.map { |v| env_expand_i(env.dup, key, v) }
+  end
+
   # for long-running processes (sox/play/ecasound filters)
   def dtas_spawn(env, cmd, opts)
     opts = { close_others: true, pgroup: true }.merge!(opts)
@@ -51,7 +75,7 @@ def dtas_spawn(env, cmd, opts)
 
     pid = spawn(env, cmd, opts)
     warn [ :spawn, pid, cmd ].inspect if $DEBUG
-    @spawn_at = Time.now.to_f
+    @spawn_at = DTAS.now
     PIDS[pid] = self
     pid
   end
@@ -63,12 +87,13 @@ def qx(env, cmd = {}, opts = {})
       cmd, opts = env, cmd
       env = {}
     end
-    r, w = IO.pipe
+    buf = ''
+    r, w = DTAS::Nonblock.pipe
     opts = opts.merge(out: w)
     r.binmode
     no_raise = opts.delete(:no_raise)
     if err_str = opts.delete(:err_str)
-      re, we = IO.pipe
+      re, we = DTAS::Nonblock.pipe
       re.binmode
       opts[:err] = we
     end
@@ -82,12 +107,11 @@ def qx(env, cmd = {}, opts = {})
       begin
         readable = IO.select(want.keys) or next
         readable[0].each do |io|
-          begin
-            want[io] << io.read_nonblock(2000)
-          rescue Errno::EAGAIN
-            # spurious wakeup, bytes may be zero
-          rescue EOFError
-            want.delete(io)
+          case rv = io.read_nonblock(2000, buf, exception: false)
+          when :wait_readable # spurious wakeup, bytes may be zero
+          when nil then want.delete(io)
+          else
+            want[io] << rv
           end
         end
       end until want.empty?

data/lib/dtas/sigevent/pipe.rb

@@ -3,11 +3,13 @@
 
 # used in various places for safe wakeups from IO.select via signals
 # A fallback for non-Linux systems lacking the "sleepy_penguin" RubyGem
+require_relative 'nonblock'
 class DTAS::Sigevent # :nodoc:
   attr_reader :to_io
 
   def initialize
-    @to_io, @wr = IO.pipe
+    @to_io, @wr = DTAS::Nonblock.pipe
+    @rbuf = ''
   end
 
   def signal
@@ -15,11 +17,10 @@ def signal
   end
 
   def readable_iter
-    begin
-      @to_io.read_nonblock(11)
+    case @to_io.read_nonblock(11, @rbuf, exception: false)
+    when :wait_readable then return :wait_readable
+    else
       yield self, nil # calls DTAS::Process.reaper
-    rescue Errno::EAGAIN
-      return :wait_readable
     end while true
   end
 

data/lib/dtas/sink.rb

@@ -91,7 +91,7 @@ def sink_spawn(format, opts = {})
         w.sink = self
         rv << w
       end
-      opts[:in] = "/dev/null"
+      opts[:in] = DTAS.null
 
       # map to real /dev/fd/* values and setup proper redirects
       cmd = cmd.gsub(DEVFD_RE) do

data/lib/dtas/source/splitfx.rb

@@ -17,6 +17,7 @@ class DTAS::Source::SplitFX < DTAS::Source::Sox # :nodoc:
 
   def initialize(sox = DTAS::Source::Sox.new)
     command_init(SPLITFX_DEFAULTS)
+    @watch_extra = []
     @sox = sox
   end
 
@@ -65,6 +66,19 @@ def src_spawn(player_format, rg_state, opts)
     e = @env.merge!(player_format.to_env)
     @sfx.infile_env(e, @sox.infile)
 
+    # watch any scripts or files the command in the YAML file refers to
+    if c = @sfx.command
+      @sfx.expand_cmd(e, c).each do |f|
+        File.readable?(f) and @watch_extra << f
+      end
+    end
+
+    # allow users to specify explicit depdendencies to watch for edit
+    case extra = @ymlhash['deps']
+    when Array, String
+      @watch_extra.concat(Array(extra))
+    end
+
     # make sure these are visible to the "current" command...
     e["TRIMFX"] = trimfx
     e["RGFX"] = rg_state.effect(self) || nil

data/lib/dtas/splitfx.rb

@@ -10,18 +10,28 @@
 # Unlike the stuff for dtas-player, dtas-splitfx is fairly tied to sox
 # (but we may still pipe to ecasound or anything else)
 class DTAS::SplitFX # :nodoc:
-  CMD = 'sox "$INFILE" $COMMENTS $OUTFMT "$OUTDIR$TRACKNUMBER.$SUFFIX" '\
-        '$TRIMFX $FX $RATEFX $DITHERFX'
+  CMD = 'sox "$INFILE" $COMMENTS $OUTFMT $OUTDST $TRIMFX $FX $RATEFX $DITHERFX'
   include DTAS::Process
   include DTAS::XS
-  attr_reader :infile, :env
+  attr_reader :infile, :env, :command
+
+  # for --trim on the command-line
+  class UTrim # :nodoc:
+    attr_reader :env, :comments
+    def initialize(trim_arg, env, comments)
+      @env = env.merge("TRIMFX" => "trim #{trim_arg}")
+      @comments = comments.merge('TRACKNUMBER' => '000')
+    end
+  end
 
+  # declare section to skip
   class Skip < Struct.new(:tbeg) # :nodoc:
     def commit(_)
       # noop
     end
   end
 
+  # a standard "track" for splitfx
   class T < Struct.new(:env, :comments, :tbeg, :fade_in, :fade_out) # :nodoc:
     def commit(advance_track_samples)
       tlen = advance_track_samples - tbeg
@@ -69,21 +79,6 @@ def initialize
           "channels" => 2,
         },
       },
-      "opusenc" => {
-        "command" => 'sox "$INFILE" $COMMENTS $OUTFMT - ' \
-           '$TRIMFX $FX $RATEFX $DITHERFX | opusenc --music ' \
-           '--raw-bits $BITS_PER_SAMPLE ' \
-           '$OPUSENC_BITRATE --raw-rate $RATE --raw-chan $CHANNELS ' \
-           '--raw-endianness $ENDIAN_OPUSENC ' \
-           '$OPUSENC_COMMENTS ' \
-           '- $OUTDIR$TRACKNUMBER.opus',
-        "format" => {
-          "bits" => 16,
-          "rate" => 48000,
-          "type" => "s16",
-          "channels" => 2,
-        },
-      },
     }
     @tracks = []
     @infmt = nil # wait until input is assigned
@@ -159,13 +154,15 @@ def load_input!(hash)
   def generic_target(target = "flac")
     outfmt = @infmt.dup
     outfmt.type = target
-    outfmt.bits = @bits if @bits
-    outfmt.rate = @rate if @rate
     { "command" => CMD, "format" => outfmt }
   end
 
   def splitfx_spawn(target, t, opts)
-    target = @targets[target] || generic_target(target)
+    if tgt = @targets[target]
+      target = tgt
+    else
+      target = generic_target(target)
+    end
     outfmt = target["format"]
 
     # default format:
@@ -173,6 +170,14 @@ def splitfx_spawn(target, t, opts)
       outfmt = @infmt.dup
       outfmt.type = "flac"
     end
+
+    outfmt.bits = @bits if @bits
+    outfmt.rate = @rate if @rate
+
+    # player commands will use SOXFMT by default, so we must output that
+    # as a self-describing format to the actual encoding instances
+    player_cmd = @command
+    suffix = outfmt.type
     env = outfmt.to_env
 
     # set very high quality resampling if using 24-bit or higher output
@@ -204,8 +209,9 @@ def splitfx_spawn(target, t, opts)
     outarg = outfmt.to_sox_arg
     outarg << "-C#@compression" if @compression
     env["OUTFMT"] = xs(outarg)
-    env["SUFFIX"] = outfmt.type
+    env["SUFFIX"] = suffix
     env["OUTDIR"] = @outdir ? "#@outdir/".squeeze('/') : ''
+    env["OUTDST"] = opts[:sox_pipe] ? "-p" : "$OUTDIR$TRACKNUMBER.$SUFFIX"
     env.merge!(t.env)
 
     command = target["command"]
@@ -215,22 +221,25 @@ def splitfx_spawn(target, t, opts)
     # already takes those into account.  In other words, use our
     # target-specific commands like a dtas-player sink:
     #   @command | (INFILE= FX= TRIMFX=; target['command'])
-    if player_cmd = @command
-      sub_env = { 'INFILE' => '-', 'FX' => '', 'TRIMFX' => '' }
-      sub_env_s = sub_env.inject("") { |s,(k,v)| s << "#{k}=#{v} " }
+    if player_cmd
+      sub_env = {
+        'INFILE' => '-p',
+        'FX' => '',
+        'TRIMFX' => '',
+        'SOXFMT' => ''
+      }
+      env['SOXFMT'] = '-tsox'
+      sub_env['OUTFMT'] = env.delete('OUTFMT')
+      sub_env_s = sub_env.inject("") { |s,(k,v)| s << "#{k}=\"#{v}\" " }
+      show_cmd = [ expand_cmd(env, player_cmd), '|', '(', "#{sub_env_s};",
+                   expand_cmd(env.merge(sub_env), command), ')' ].flatten
       command = "#{player_cmd} | (#{sub_env_s}; #{command})"
-      show_cmd = [ _expand_cmd(env, player_cmd), '|', '(', "#{sub_env_s};",
-                   _expand_cmd(env.merge(sub_env), command), ')' ].flatten
     else
-      show_cmd = _expand_cmd(env, command)
+      show_cmd = expand_cmd(env, command)
     end
 
-    echo = "echo #{xs(show_cmd)}"
-    if opts[:dryrun]
-      command = echo
-    else
-      system(echo) unless opts[:silent]
-    end
+    @out.puts(show_cmd.join(' ')) unless opts[:silent]
+    command = 'true' if opts[:dryrun] # still gotta fork
 
     # pgroup: false so Ctrl-C on command-line will immediately stop everything
     [ dtas_spawn(env, command, pgroup: false), comments ]
@@ -339,11 +348,18 @@ def run(target, opts = {})
     @compression = opts[:compression]
     @rate = opts[:rate]
     @bits = opts[:bits]
+    trim = opts[:trim] and @tracks = [ UTrim.new(trim, @env, @comments) ]
 
     fails = []
     tracks = @tracks.dup
     pids = {}
     jobs = opts[:jobs] || tracks.size # jobs == nil => everything at once
+    if opts[:sox_pipe]
+      jobs = 1
+      @out = $stderr
+    else
+      @out = $stdout
+    end
     jobs.times.each do
       t = tracks.shift or break
       pid, tmp = splitfx_spawn(target, t, opts)
@@ -358,7 +374,7 @@ def run(target, opts = {})
           pid, tmp = splitfx_spawn(target, t, opts)
           pids[pid] = [ t, tmp ]
         end
-        puts "DONE #{done[0].inspect}" if $DEBUG
+        @out.puts "DONE #{done[0].inspect}" if $DEBUG
         done[1].close!
       else
         fails << [ t, status ]
@@ -385,7 +401,7 @@ def infile_env(env, infile)
     env["INBASE"] = xs(base)
   end
 
-  def _expand_cmd(env, command)
+  def expand_cmd(env, command) # for display purposes only
     Shellwords.split(command).map do |arg|
       qx(env, "printf %s \"#{arg}\"")
     end

data/lib/dtas/track.rb

@@ -0,0 +1,13 @@
+# Copyright (C) 2015 all contributors <dtas-all@nongnu.org>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require_relative '../dtas'
+
+class DTAS::Track
+  attr_reader :track_id
+  attr_reader :to_path
+
+  def initialize(track_id, path)
+    @track_id = track_id
+    @to_path = path
+  end
+end

data/lib/dtas/tracklist.rb

@@ -2,97 +2,157 @@
 # License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
 require_relative '../dtas'
 require_relative 'serialize'
+require_relative 'track'
 
 # the a tracklist object for -player
 # this is inspired by the MPRIS 2.0 TrackList spec
 class DTAS::Tracklist # :nodoc:
   include DTAS::Serialize
   attr_accessor :repeat # true, false, 1
+  attr_reader :shuffle  # false or shuffled @list
+  attr_accessor :max # integer
 
-  SIVS = %w(list pos repeat)
   TL_DEFAULTS = {
-    "list" => [],
-    "pos" => -1,
-    "repeat" => false,
+    'pos' => -1,
+    'repeat' => false,
+    'max' => 20_000,
   }
+  SIVS = TL_DEFAULTS.keys
 
   def self.load(hash)
     obj = new
     obj.instance_eval do
-      list = hash["list"] and @list.replace(list)
-      @pos = hash["pos"] || -1
-      @repeat = hash["repeat"] || false
+      list = hash['list'] and @list.replace(list.map { |s| new_track(s) })
+      SIVS.each do |k|
+        instance_variable_set("@#{k}", hash[k] || TL_DEFAULTS[k])
+      end
+
+      # n.b.: we don't check @list.size against max here in case people
+      # are migrating
+
+      if hash['shuffle']
+        @shuffle = @list.shuffle
+        @pos = _idx_of(@shuffle, @list[@pos].track_id) if @pos >= 0
+      end
     end
     obj
   end
 
-  def to_hsh
-    ivars_to_hash(SIVS).delete_if { |k,v| TL_DEFAULTS[k] == v }
+  def to_hsh(full_list = true)
+    h = ivars_to_hash(SIVS)
+    h.delete_if { |k,v| TL_DEFAULTS[k] == v }
+    unless @list.empty?
+      if full_list
+        h['list'] = @list.map(&:to_path)
+      else
+        h['size'] = @list.size
+      end
+    end
+    if @shuffle
+      h['shuffle'] = true
+      h['pos'] = _idx_of(@list, @shuffle[@pos].track_id) if @pos >= 0
+    end
+    h
   end
 
   def initialize
     TL_DEFAULTS.each { |k,v| instance_variable_set("@#{k}", v) }
     @list = []
     @goto_off = @goto_pos = nil
+    @track_nr = 0
+    @shuffle = false
+  end
+
+  def new_track(path)
+    n = @track_nr += 1
+
+    # nobody needs a billion tracks in their tracklist, right?
+    # avoid promoting to Bignum on 32-bit
+    @track_nr = n = 1 if n >= 0x3fffffff
+
+    DTAS::Track.new(n, path)
   end
 
   def reset
     @goto_off = @goto_pos = nil
     @pos = TL_DEFAULTS["pos"]
+    @shuffle.shuffle! if @shuffle
   end
 
-  def size
-    @list.size
+  def get_tracks(track_ids)
+    want = {}
+    track_ids.each { |i| want[i] = i }
+    rv = []
+    @list.each do |t|
+      i = want[t.track_id] and rv << [ i, t.to_path ]
+    end
+    rv
   end
 
-  # caching this probably isn't worth it.  a tracklist is usually
-  # a few tens of tracks, maybe a hundred at most.
-  def _track_id_map
-    by_track_id = {}
-    @list.each_with_index { |t,i| by_track_id[t.object_id] = i }
-    by_track_id
+  def _update_pos(pos, prev, list)
+    old = prev[pos]
+    _idx_of(list, old.track_id)
   end
 
-  def get_tracks(track_ids)
-    by_track_id = _track_id_map
-    track_ids.map do |track_id|
-      idx = by_track_id[track_id]
-      # dtas-mpris fills in the metadata, we just return a path
-      [ track_id, idx ? @list[idx] : nil ]
+  def shuffle=(bool)
+    prev = @shuffle
+    if bool
+      list = @shuffle = (prev ||= @list).shuffle
+    elsif prev
+      @shuffle = false
+      list = @list
+    else
+      return false
     end
+    @pos = _update_pos(@pos, prev, list) if @pos >= 0
+    @goto_pos = _update_pos(@goto_pos, prev, list) if @goto_pos
   end
 
   def tracks
-    @list.map(&:object_id)
+    @list.map(&:track_id)
   end
 
   def advance_track(repeat_ok = true)
-    return if @list.empty?
+    cur = @shuffle || @list
+    return if cur.empty?
     # @repeat == 1 for single track repeat
     repeat = repeat_ok ? @repeat : false
     next_pos = @goto_pos || @pos + (repeat == 1 ? 0 : 1)
     next_off = @goto_off # nil by default
     @goto_pos = @goto_off = nil
-    if @list[next_pos]
+    if cur[next_pos]
       @pos = next_pos
     elsif repeat
       next_pos = @pos = 0
     else
       return
     end
-    [ @list[next_pos], next_off ]
+    [ cur[next_pos].to_path, next_off ]
   end
 
   def cur_track
-    @pos >= 0 ? @list[@pos] : nil
+    @pos >= 0 ? (@shuffle || @list)[@pos] : nil
   end
 
   def add_track(track, after_track_id = nil, set_as_current = false)
+    return false if @list.size >= @max
+
+    track = new_track(track)
     if after_track_id
-      by_track_id = _track_id_map
-      idx = by_track_id[after_track_id] or
-        raise ArgumentError, "after_track_id invalid"
+      idx = _idx_of(@list, after_track_id) or
+                                  raise ArgumentError, 'after_track_id invalid'
+      if @shuffle
+        _idx_of(@shuffle, after_track_id) or
+                                  raise ArgumentError, 'after_track_id invalid'
+      end
       @list[idx, 1] = [ @list[idx], track ]
+
+      # add into random position if shuffling
+      if @shuffle
+        idx = rand(@shuffle.size)
+        @shuffle[idx, 1] = [ @shuffle[idx], track ]
+      end
+
       if set_as_current
         @pos = idx + 1
       else
@@ -100,33 +160,57 @@ def add_track(track, after_track_id = nil, set_as_current = false)
       end
     else # nil = first_track
       @list.unshift(track)
-      if set_as_current
-        @pos = 0
+
+      if @shuffle
+        if @shuffle.empty?
+          @shuffle << track
+          @pos = 0 if set_as_current
+        else
+          idx = rand(@shuffle.size)
+          @shuffle[idx, 1] = [ @shuffle[idx], track ]
+          @pos = idx + 1 if set_as_current
+        end
       else
-        @pos += 1 if @pos >= 0
+        if set_as_current
+          @pos = 0
+        else
+          @pos += 1 if @pos >= 0
+        end
       end
     end
-    track.object_id
+    track.track_id
+  end
+
+  def _idx_of(list, track_id)
+    list.index { |t| t.track_id == track_id }
   end
 
   def remove_track(track_id)
-    by_track_id = _track_id_map
-    idx = by_track_id.delete(track_id) or return false
-    @list[idx] = nil
-    @list.compact!
+    idx = _idx_of(@list, track_id) or return false
+    if @shuffle
+      si = _idx_of(@shuffle, track_id) or return false
+      @shuffle.delete_at(si)
+    end
+    track = @list.delete_at(idx)
     len = @list.size
     if @pos >= len
       @pos = len == 0 ? TL_DEFAULTS["pos"] : len
     end
     @goto_pos = @goto_pos = nil # TODO: reposition?
-    true
+    track.to_path
+  end
+
+  def clear
+    @list.clear
+    @shuffle.clear if @shuffle
+    reset
   end
 
   def go_to(track_id, offset_hhmmss = nil)
-    by_track_id = _track_id_map
-    if idx = by_track_id[track_id]
+    list = @shuffle || @list
+    if idx = _idx_of(list, track_id)
       @goto_off = offset_hhmmss
-      return @list[@goto_pos = idx]
+      return list[@goto_pos = idx].to_path
     end
     @goto_pos = nil
     # noop if track_id is invalid
@@ -141,4 +225,25 @@ def previous!
     end
     @goto_pos = prev_idx
   end
+
+  def swap(a_id, b_id)
+    ok = { a_id => a_idx = [], b_id => b_idx = [] }
+    @list.each_with_index do |t,i|
+      ary = ok.delete(t.track_id) or next
+      ary[0] = i
+      break if ok.empty?
+    end
+    a_idx = a_idx[0] or return
+    b_idx = b_idx[0] or return
+    @list[a_idx], @list[b_idx] = @list[b_idx], @list[a_idx]
+    unless @shuffle
+      [ :@goto_pos, :@pos ].each do |v|
+        case instance_variable_get(v)
+        when a_idx then instance_variable_set(v, b_idx)
+        when b_idx then instance_variable_set(v, a_idx)
+        end
+      end
+    end
+    true
+  end
 end