dtas 0.3.0 → 0.4.0

data/bin/dtas-tl

@@ -0,0 +1,73 @@
+#!/usr/bin/env ruby
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net> and all contributors
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+#
+# WARNING: totally unstable API, use dtas-ctl for scripting (but the protocol
+# itself is also unstable, but better than this one probably).
+require 'dtas/unix_client'
+require 'yaml'
+require 'shellwords'
+
+def get_track_ids(c)
+  track_ids = c.req("tl tracks")
+  # we could get more, but SEQPACKET limits size...
+  track_ids = track_ids.split(/ /)
+  track_ids.shift
+  track_ids
+end
+
+c = DTAS::UNIXClient.new
+case cmd = ARGV[0]
+when "cat"
+  get_track_ids(c).each do |track_id|
+    res = c.req("tl get #{track_id}")
+    res.sub!(/\A1 /, '')
+    puts res
+  end
+when "clear"
+  get_track_ids(c).each do |track_id|
+    puts "#{track_id} " << c.req("tl remove #{track_id}")
+  end
+when "addhead"
+  ARGV.shift
+  ARGV.reverse.each do |path|
+    path = File.expand_path(path.b)
+    res = c.req(%W(tl add #{path}))
+    puts "#{path} #{res}"
+  end
+when "addtail"
+  ARGV.shift
+  track_ids = get_track_ids(c)
+  last_id = track_ids.pop
+  ARGV.each do |path|
+    path = File.expand_path(path.b)
+    req = %W(tl add #{path})
+    req << last_id.to_s if last_id
+    res = c.req(req)
+    puts "#{path} #{res}"
+    last_id = res if res =~ /\A\d+\z/
+  end
+when "reto"
+  fixed = ARGV.delete("-F")
+  ignorecase = ARGV.delete("-i")
+  re = ARGV[1]
+  time = ARGV[2]
+  re = Regexp.quote(re) if fixed
+  re = ignorecase ? %r{#{re}}i : %r{#{re}}
+  get_track_ids(c).each do |track_id|
+    res = c.req("tl get #{track_id}")
+    res.sub!(/\A1 /, '')
+    if re =~ res
+      req = %W(tl goto #{track_id})
+      req << time if time
+      res = c.req(req)
+      puts res
+      exit(res == "OK")
+    end
+  end
+  warn "#{re.inspect} not found"
+  exit 1
+else
+  # act like dtas-ctl for now...
+  puts c.req([ "tl", *ARGV ])
+end

data/examples/README

@@ -0,0 +1,3 @@
+All files in this example directory (including this one) are CC0:
+To the extent possible under law, Eric Wong has waived all copyright and
+related or neighboring rights to these examples.

data/examples/splitfx.sample.yml

@@ -0,0 +1,19 @@
+# To the extent possible under law, Eric Wong has waived all copyright and
+# related or neighboring rights to this example.
+# Note: be sure to update test/test_splitfx.rb if you change this,
+# test_splitfx.rb relies on this.
+---
+infile: foo.flac
+env:
+  PATH: $PATH
+  SOX_OPTS: $SOX_OPTS -R
+comments:
+  ARTIST: John Smith
+  ALBUM: Hello World
+  YEAR: 2013
+track_start: 1 # 0 for pregap/intro tracks
+cdda_align: true
+tracks:
+  - t 0:04 "track one"
+  - t 0:10 "track two"
+  - stop 24

data/lib/dtas/format.rb

@@ -59,6 +59,16 @@ class DTAS::Format # :nodoc:
     end
   end
 
+  # returns 1 or 0 depending on endianess
+  def endian_opusenc
+    case e = @endian || NATIVE_ENDIAN
+    when "big" then "1"
+    when "little" then "0"
+    else
+      raise"unsupported endian=#{e}"
+    end
+  end
+
   def to_eca_arg
     %W(-f #{@type}_#{endian2},#@channels,#@rate)
   end
@@ -92,6 +102,7 @@ class DTAS::Format # :nodoc:
       "SOXFMT" => to_sox_arg.join(' '),
       "ECAFMT" => to_eca_arg.join(' '),
       "ENDIAN2" => endian2,
+      "ENDIAN_OPUSENC" => endian_opusenc,
     }
     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

data/lib/dtas/pipe.rb

@@ -21,9 +21,6 @@ class DTAS::Pipe < IO # :nodoc:
   unless method_defined?(:pipe_size=)
     def pipe_size=(_)
     end
-
-    def pipe_size
-    end
   end
 end
 

data/lib/dtas/player.rb

@@ -15,6 +15,7 @@ require_relative 'buffer'
 require_relative 'sigevent'
 require_relative 'rg_state'
 require_relative 'state_file'
+require_relative 'tracklist'
 
 class DTAS::Player # :nodoc:
   require_relative 'player/client_handler'
@@ -25,6 +26,7 @@ class DTAS::Player # :nodoc:
   attr_reader :sinks
 
   def initialize
+    @tl = DTAS::Tracklist.new
     @state_file = nil
     @socket = nil
     @srv = nil
@@ -52,7 +54,7 @@ class DTAS::Player # :nodoc:
     @sources = @source_map.values.sort_by { |src| src.tryorder }
   end
 
-  def echo(msg)
+  def wall(msg)
     msg = xs(Array(msg))
     @watchers.delete_if do |io, _|
       if io.closed?
@@ -87,6 +89,8 @@ class DTAS::Player # :nodoc:
       rv[k] = instance_variable_get("@#{k}").to_hsh
     end
 
+    rv["tracklist"] = @tl.to_hsh
+
     # no empty hashes or arrays
     rv.delete_if do |k,v|
       case v
@@ -111,6 +115,9 @@ class DTAS::Player # :nodoc:
   def self.load(hash)
     rv = new
     rv.instance_eval do
+      if v = hash["tracklist"]
+        @tl = DTAS::Tracklist.load(v)
+      end
       @rg = DTAS::RGState.load(hash["rg"])
       if v = hash["sink_buf"]
         v = v["buffer_size"]
@@ -190,7 +197,7 @@ class DTAS::Player # :nodoc:
       do_seek(io, msg[0])
     when "clear"
       @queue.clear
-      echo("clear")
+      wall("clear")
       io.emit("OK")
     when "rg"
       rg_handler(io, msg)
@@ -218,6 +225,8 @@ class DTAS::Player # :nodoc:
       chdir_handler(io, msg)
     when "pwd"
       io.emit(Dir.pwd)
+    when "tl"
+      tl_handler(io, msg)
     end
   end
 
@@ -242,7 +251,7 @@ class DTAS::Player # :nodoc:
       obj.on_death(status) if obj.respond_to?(:on_death)
       case obj
       when @current
-        next_source(@paused ? nil : @queue.shift)
+        next_source(@paused ? nil : _next)
       when DTAS::Sink # on unexpected sink death
         sink_death(obj, status)
       end
@@ -250,6 +259,10 @@ class DTAS::Player # :nodoc:
     :wait_readable
   end
 
+  def _next
+    @queue.shift || @tl.advance_track
+  end
+
   def sink_death(sink, status)
     deleted = []
     @targets.delete_if do |t|
@@ -272,7 +285,7 @@ class DTAS::Player # :nodoc:
     if (@current || @queue[0]) && !@paused
       # we get here if source/sinks are all killed in restart_pipeline
       __sink_activate(sink)
-      next_source(@queue.shift) unless @current
+      next_source(_next) unless @current
     end
   end
 
@@ -337,7 +350,16 @@ class DTAS::Player # :nodoc:
         rv = src.try(*source_spec) and return rv
       end
     end
-    echo "idle"
+
+    # don't get stuck in an infinite loop if @tl.repeat==true and we can't
+    # decode anything (FS errors, sox uninstalled, etc...)
+    while path_off = @tl.advance_track(false)
+      @sources.each do |src|
+        rv = src.try(*path_off) and return rv
+      end
+    end
+
+    player_idle
     nil
   end
 
@@ -350,13 +372,13 @@ class DTAS::Player # :nodoc:
       case source_spec
       when String
         pending = try_file(source_spec) or return
-        echo(%W(file #{pending.infile}))
+        wall(%W(file #{pending.infile}))
       when Array
         pending = try_file(*source_spec) or return
-        echo(%W(file #{pending.infile} #{pending.offset_samples}s))
+        wall(%W(file #{pending.infile} #{pending.offset_samples}s))
       else
         pending = DTAS::Source::Cmd.new(source_spec["command"])
-        echo(%W(command #{pending.command_string}))
+        wall(%W(command #{pending.command_string}))
       end
 
       dst = @sink_buf
@@ -365,11 +387,16 @@ class DTAS::Player # :nodoc:
       @current = pending
       @srv.wait_ctl(dst, :wait_readable)
     else
-      stop_sinks if @sink_buf.inflight == 0
-      echo "idle"
+      player_idle
     end
   end
 
+  def player_idle
+    stop_sinks if @sink_buf.inflight == 0
+    @tl.reset unless @paused
+    wall("idle")
+  end
+
   def drop_target(target)
     @srv.wait_ctl(target, :delete)
     target.close
@@ -410,7 +437,7 @@ class DTAS::Player # :nodoc:
     @srv.wait_ctl(sev, :wait_readable)
     old_chld = trap(:CHLD) { sev.signal }
     create_default_sink
-    next_source(@paused ? nil : @queue.shift)
+    next_source(@paused ? nil : _next)
     begin
       event_loop_iter
     rescue => e # just in case...

data/lib/dtas/player/client_handler.rb

@@ -317,7 +317,7 @@ module DTAS::Player::ClientHandler # :nodoc:
 
   def skip_handler(io, msg)
     __current_drop
-    echo("skip")
+    wall("skip")
     io.emit("OK")
   end
 
@@ -334,16 +334,16 @@ module DTAS::Player::ClientHandler # :nodoc:
 
   def do_pause
     return if @paused
-    echo("pause")
+    wall("pause")
     @paused = true
     __current_requeue
   end
 
   def do_play
-    # no echo, next_source will echo on new track
+    # no wall, next_source will wall on new track
     @paused = false
     return if @current
-    next_source(@queue.shift)
+    next_source(_next)
   end
 
   def do_play_pause
@@ -363,8 +363,13 @@ module DTAS::Player::ClientHandler # :nodoc:
         rescue ArgumentError
           return io.emit("ERR bad time format")
         end
-        @queue.unshift([ @current.infile, offset ])
-        __buf_reset(@current.dst) # trigger EPIPE
+        if @current.requeued
+          @queue[0][1] = offset
+        else
+          @queue.unshift([ @current.infile, offset ])
+          @current.requeued = true
+          __buf_reset(@current.dst) # trigger EPIPE
+        end
       else
         return io.emit("ERR unseekable")
       end
@@ -484,7 +489,7 @@ module DTAS::Player::ClientHandler # :nodoc:
     rescue => e
       return io.emit("ERR chdir: #{e.message}")
     end
-    # echo(%W(cd msg[0])) # should we broadcast this?
+    # wall(%W(cd msg[0])) # should we broadcast this?
     io.emit("OK")
   end
 
@@ -508,5 +513,87 @@ module DTAS::Player::ClientHandler # :nodoc:
     end
     io.emit("OK")
   end
+
+  def _tl_skip
+    @queue.clear
+    __current_drop
+  end
+
+  def tl_handler(io, msg)
+    case msg.shift
+    when "add"
+      path = msg.shift
+      after_track_id = msg.shift
+      after_track_id = after_track_id.to_i if after_track_id
+      case set_as_current = msg.shift
+      when "true" then set_as_current = true
+      when "false", nil then set_as_current = false
+      else
+        return io.emit("ERR tl add PATH [after_track_id] [true|false]")
+      end
+      begin
+        track_id = @tl.add_track(path, after_track_id, set_as_current)
+      rescue ArgumentError => e
+        return io.emit("ERR #{e.message}")
+      end
+      _tl_skip if set_as_current
+
+      # start playing if we're the only track
+      if @tl.size == 1 && !(@current || @queue[0] || @paused)
+        next_source(_next)
+      end
+      io.emit("#{track_id}")
+    when "repeat"
+      case msg.shift
+      when "true" then @tl.repeat = true
+      when "false" then @tl.repeat = false
+      when "1" then @tl.repeat = 1
+      when nil
+        return io.emit("repeat #{@tl.repeat.to_s}")
+      end
+      io.emit("OK")
+    when "remove"
+      track_id = msg.shift or return io.emit("ERR track_id not specified")
+      track_id = track_id.to_i
+      cur = @tl.cur_track
+
+      # skip if we're removing the currently playing track
+      if cur.object_id == track_id && @current &&
+             @current.respond_to?(:infile) && @current.infile == cur
+        _tl_skip
+      end
+
+      io.emit(@tl.remove_track(track_id) ? "OK" : "MISSING")
+    when "get"
+      res = @tl.get_tracks(msg.map! { |i| i.to_i })
+      res.map! { |tid, file| "#{tid}=#{file ? Shellwords.escape(file) : ''}" }
+      io.emit("#{res.size} #{res.join(' ')}")
+    when "tracks"
+      tracks = @tl.tracks
+      io.emit("#{tracks.size} " << tracks.map! { |i| i.to_s }.join(' '))
+    when "goto"
+      track_id = msg.shift or return io.emit("ERR track_id not specified")
+      offset = msg.shift # may be nil
+      if @tl.go_to(track_id.to_i, offset)
+        _tl_skip
+        io.emit("OK")
+      else
+        io.emit("MISSING")
+      end
+    when "current"
+      path = @tl.cur_track
+      io.emit(path ? path : "NONE")
+    when "current-id"
+      path = @tl.cur_track
+      io.emit(path ? path.object_id.to_s : "NONE")
+    when "next"
+      _tl_skip
+      io.emit("OK")
+    when "previous"
+      @tl.previous!
+      _tl_skip
+      io.emit("OK")
+    end
+  end
 end
 # :startdoc:

data/lib/dtas/process.rb

@@ -19,12 +19,33 @@ module DTAS::Process # :nodoc:
     end while true
   end
 
+  # expand common shell constructs based on environment variables
+  # this is order-dependent, but Ruby 1.9+ hashes are already order-dependent
+  def env_expand(env, opts)
+    env = env.dup
+    if false == opts.delete(:expand)
+      env.each do |key, val|
+        Numeric === val and env[key] = val.to_s
+      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
+        end
+      end
+    end
+  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 }
+    env = env_expand(env, opts)
 
     pid = begin
       Process.spawn(env, cmd, opts)
@@ -53,6 +74,7 @@ module DTAS::Process # :nodoc:
       re.binmode
       opts[:err] = we
     end
+    env = env_expand(env, opts)
     pid = begin
       Process.spawn(env, *cmd, opts)
     rescue Errno::EINTR # Ruby bug?