dtas 0.0.0 → 0.1.I

data/lib/dtas/source/ff.rb

@@ -0,0 +1,30 @@
+# -*- 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'
+
+# ffmpeg support
+# note: only tested with the compatibility wrapper in the Debian 7.0 package
+# (so still using avconv/avprobe)
+class DTAS::Source::Ff  # :nodoc:
+  include DTAS::Source::AvFfCommon
+
+  FF_DEFAULTS = COMMAND_DEFAULTS.merge(
+    "command" =>
+      'ffmpeg -v error $SSPOS -i "$INFILE" $AMAP -f sox - |' \
+      'sox -p $SOXFMT - $RGFX',
+
+    # I haven't tested this much since av is in Debian stable and ff is not
+    "tryorder" => 2,
+  )
+
+  def initialize
+    command_init(FF_DEFAULTS)
+    @av_ff_probe = "ffprobe"
+  end
+
+  def source_defaults
+    FF_DEFAULTS
+  end
+end

data/lib/dtas/source/file.rb

@@ -0,0 +1,94 @@
+# -*- 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 '../command'
+require_relative '../format'
+require_relative '../process'
+
+module DTAS::Source::File # :nodoc:
+  attr_reader :infile
+  attr_reader :offset
+  attr_accessor :tryorder
+  require_relative 'common' # dtas/source/common
+  require_relative 'mp3gain'
+  include DTAS::Command
+  include DTAS::Process
+  include DTAS::Source::Common
+  include DTAS::Source::Mp3gain
+
+  FILE_SIVS = %w(infile comments command env) # for the "current" command
+  SRC_SIVS = %w(command env tryorder)
+
+  def source_file_dup(infile, offset)
+    rv = dup
+    rv.__file_init(infile, offset)
+    rv
+  end
+
+  def __file_init(infile, offset)
+    @env = @env.dup
+    @format = nil
+    @infile = infile
+    @offset = offset
+    @comments = nil
+    @samples = nil
+    @rg = 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
+
+  # A user may be downloading the file and start playing
+  # it before the download completes, this refreshes
+  def samples!
+    @samples = nil
+    samples
+  end
+
+  def comments
+    @comments ||= __load_comments
+  end
+
+  def to_hash
+    rv = ivars_to_hash(FILE_SIVS)
+    rv["samples"] = samples
+    rv
+  end
+
+  def replaygain
+    @rg ||= DTAS::ReplayGain.new(comments) ||
+            DTAS::ReplayGain.new(mp3gain_comments)
+  end
+
+  def to_source_cat
+    ivars_to_hash(SRC_SIVS)
+  end
+
+  def load!(src_hsh)
+    SRC_SIVS.each do |field|
+      val = src_hsh[field] and instance_variable_set("@#{field}", val)
+    end
+  end
+
+  def to_state_hash
+    defaults = source_defaults # see dtas/source/{av,sox}.rb
+    to_source_cat.delete_if { |k,v| v == defaults[k] }
+  end
+end

data/lib/dtas/source/{mp3.rb → mp3gain.rb}

@@ -3,7 +3,7 @@
 # License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
 require_relative '../process'
 
-module DTAS::Source::Mp3 # :nodoc:
+module DTAS::Source::Mp3gain # :nodoc:
   include DTAS::Process
   # we use dBFS = 1.0 as scale (not 32768)
   def __mp3gain_peak(str)

data/lib/dtas/source/sox.rb

@@ -0,0 +1,114 @@
+# -*- 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'
+
+# this is usually one input file
+class DTAS::Source::Sox # :nodoc:
+  require_relative 'file'
+
+  include DTAS::Source::File
+
+  SOX_DEFAULTS = COMMAND_DEFAULTS.merge(
+    "command" => 'exec sox "$INFILE" $SOXFMT - $TRIMFX $RGFX',
+    "tryorder" => 0,
+  )
+
+  # we use this to be less noisy when seeking a file
+  @last_failed = nil
+  def self.try_to_fail_harder(infile, s, cmd)
+    msg = nil
+    case s
+    when %r{\A0\s*\z} then msg = "detected zero samples"
+    when Process::Status then msg = "failed with #{s.exitstatus}"
+    end
+    if msg
+      return if @last_failed == infile
+      @last_failed = infile
+      return warn("`#{Shellwords.join(cmd)}' #{msg}")
+    end
+    true
+  end
+
+  def initialize
+    command_init(SOX_DEFAULTS)
+  end
+
+  def try(infile, offset = nil)
+    err = ""
+    cmd = %W(soxi -s #{infile})
+    s = qx(@env, cmd, err_str: err, no_raise: true)
+    return if err =~ /soxi FAIL formats:/
+    self.class.try_to_fail_harder(infile, s, cmd) or return
+    source_file_dup(infile, offset)
+  end
+
+  def precision
+    qx(@env, %W(soxi -p #@infile), err: "/dev/null").to_i # sox.git f4562efd0aa3
+  rescue # fallback to parsing the whole output
+    s = qx(@env, %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
+      path = @infile
+      fmt.channels = qx(@env, %W(soxi -c #{path})).to_i
+      fmt.type = qx(@env, %W(soxi -t #{path})).strip
+      fmt.rate = qx(@env, %W(soxi -r #{path})).to_i
+      fmt.bits ||= precision
+      fmt
+    end
+  end
+
+  # This is the number of samples according to the samples in the source
+  # file itself, not the decoded output
+  def samples
+    @samples ||= qx(@env, %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
+      qx(@env, %W(soxi -a #@infile)).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
+    end
+    tmp
+  end
+
+  def spawn(player_format, rg_state, opts)
+    raise "BUG: #{self.inspect}#spawn called twice" if @to_io
+    e = @env.merge!(player_format.to_env)
+    e["INFILE"] = @infile
+
+    # make sure these are visible to the "current" command...
+    e["TRIMFX"] = @offset ? "trim #@offset" : nil
+    e["RGFX"] = rg_state.effect(self) || nil
+    e.merge!(@rg.to_env) if @rg
+
+    @pid = dtas_spawn(e, command_string, opts)
+  end
+
+  def to_hsh
+    to_hash.delete_if { |k,v| v == SOX_DEFAULTS[k] }
+  end
+
+  def source_defaults
+    SOX_DEFAULTS
+  end
+end

data/lib/dtas/unix_client.rb

@@ -14,15 +14,7 @@ class DTAS::UNIXClient # :nodoc:
   end
 
   def initialize(path = self.class.default_path)
-    @to_io = begin
-      raise if ENV["_DTAS_NOSEQPACKET"]
-      Socket.new(:AF_UNIX, :SOCK_SEQPACKET, 0)
-    rescue
-      warn("get your operating system developers to support " \
-           "SOCK_SEQPACKET for AF_UNIX sockets")
-      warn("falling back to SOCK_DGRAM, reliability possibly compromised")
-      Socket.new(:AF_UNIX, :SOCK_DGRAM, 0)
-    end
+    @to_io = Socket.new(:AF_UNIX, :SOCK_SEQPACKET, 0)
     @to_io.connect(Socket.pack_sockaddr_un(path))
   end
 

data/test/player_integration.rb

@@ -4,6 +4,7 @@
 require './test/helper'
 require 'dtas/player'
 require 'dtas/state_file'
+require 'dtas/unix_client'
 require 'yaml'
 require 'tempfile'
 require 'shellwords'
@@ -46,18 +47,8 @@ module PlayerIntegration
     end
   end
 
-  module PlayerClient
-    def preq(args)
-      args = Shellwords.join(args) if Array === args
-      send(args, Socket::MSG_EOR)
-    end
-  end
-
   def client_socket
-    s = Socket.new(:AF_UNIX, :SOCK_SEQPACKET, 0)
-    s.connect(Socket.pack_sockaddr_un(@sock_path))
-    s.extend(PlayerClient)
-    s
+    DTAS::UNIXClient.new(@sock_path)
   end
 
   def wait_pid_dead(pid, time = 5)
@@ -79,8 +70,7 @@ module PlayerIntegration
   def default_sink_pid(s)
     default_pid = Tempfile.new(%w(dtas-test .pid))
     pf = "echo $$ >> #{default_pid.path}; "
-    s.send("sink ed default command='#{pf}#@cmd'", Socket::MSG_EOR)
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("sink ed default command='#{pf}#@cmd'")
     default_pid
   end
 
@@ -108,13 +98,11 @@ module PlayerIntegration
   end
 
   def dethrottle_decoder(s)
-    s.send("sink ed default active=false", Socket::MSG_EOR)
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("sink ed default active=false")
   end
 
   def stop_playback(pid_file, s)
-    s.send("skip", Socket::MSG_EOR)
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("skip")
     pid = read_pid_file(pid_file)
     wait_pid_dead(pid)
   end

data/test/test_format.rb

@@ -34,20 +34,6 @@ class TestFormat < Minitest::Unit::TestCase
     assert_nil hash["channels"]
   end
 
-  def test_from_file
-    Tempfile.open(%w(tmp .wav)) do |tmp|
-      # generate an empty file with 1s of audio
-      cmd = %W(sox -r 96000 -b 24 -c 2 -n #{tmp.path} trim 0 1)
-      system(*cmd)
-      assert $?.success?, "#{cmd.inspect} failed: #$?"
-      fmt = DTAS::Format.new
-      fmt.from_file tmp.path
-      assert_equal 96000, fmt.rate
-      assert_equal 2, fmt.channels
-      tmp.unlink
-    end
-  end
-
   def test_bytes_per_sample
     fmt = DTAS::Format.new
     assert_equal 4, fmt.bytes_per_sample
@@ -58,4 +44,14 @@ class TestFormat < Minitest::Unit::TestCase
     fmt.type = "s16"
     assert_equal 2, fmt.bytes_per_sample
   end
+
+  def test_valid_type
+    fmt = DTAS::Format.new
+    %w(s16 s24 s32 f32 f64).each do |t|
+      assert fmt.valid_type?(t)
+    end
+    %w(flac wav wtf).each do |t|
+      refute fmt.valid_type?(t)
+    end
+  end
 end

data/test/test_format_change.rb

@@ -13,15 +13,12 @@ class TestFormatChange < Minitest::Unit::TestCase
       d = "#{dir}/dump.$CHANNELS.$RATE"
       f44100 = File.open("#{dir}/dump.2.44100", IO::RDWR|IO::CREAT)
       f88200 = File.open("#{dir}/dump.2.88200", IO::RDWR|IO::CREAT)
-      s.preq("sink ed dump active=true command='cat > #{d}'")
-      assert_equal "OK", s.readpartial(666)
+      s.req_ok("sink ed dump active=true command='cat > #{d}'")
       noise, len = tmp_noise
-      s.preq(%W(enq #{noise.path}))
-      assert_equal "OK", s.readpartial(666)
+      s.req_ok(%W(enq #{noise.path}))
       wait_files_not_empty(default_pid, f44100)
 
-      s.preq("format rate=88200")
-      assert_equal "OK", s.readpartial(666)
+      s.req_ok("format rate=88200")
 
       wait_files_not_empty(f88200)
 
@@ -29,8 +26,7 @@ class TestFormatChange < Minitest::Unit::TestCase
 
       Timeout.timeout(len) do
         begin
-          s.preq("current")
-          cur = YAML.load(s.readpartial(6666))
+          cur = YAML.load(s.req("current"))
         end while cur["sinks"] && sleep(0.01)
       end
 

data/test/test_player_integration.rb

@@ -22,9 +22,8 @@ class TestPlayerIntegration < Minitest::Unit::TestCase
     default_pid = default_sink_pid(s)
     Tempfile.open('junk') do |junk|
       pink = "sox -n $SOXFMT - synth 0.0001 pinknoise | tee -i #{junk.path}"
-      s.send("enq-cmd \"#{pink}\"", Socket::MSG_EOR)
+      s.req_ok("enq-cmd \"#{pink}\"")
       wait_files_not_empty(junk)
-      assert_equal "OK", s.readpartial(666)
     end
     wait_files_not_empty(default_pid)
     pid = read_pid_file(default_pid)
@@ -36,8 +35,7 @@ class TestPlayerIntegration < Minitest::Unit::TestCase
     default_pid = default_sink_pid(s)
     cmd = Tempfile.new(%w(sox-cmd .pid))
     pink = "echo $$ > #{cmd.path}; sox -n $SOXFMT - synth 100 pinknoise"
-    s.send("enq-cmd \"#{pink}\"", Socket::MSG_EOR)
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("enq-cmd \"#{pink}\"")
     wait_files_not_empty(cmd, default_pid)
     pid = read_pid_file(default_pid)
     Process.kill(:KILL, pid)
@@ -47,31 +45,28 @@ class TestPlayerIntegration < Minitest::Unit::TestCase
 
   def test_sink_activate
     s = client_socket
-    s.send("sink ls", Socket::MSG_EOR)
-    assert_equal "default", s.readpartial(666)
+    res = s.req("sink ls")
+    assert_equal "default", res
 
     # setup two outputs
 
     # make the default sink trickle
     default_pid = Tempfile.new(%w(dtas-test .pid))
     pf = "echo $$ >> #{default_pid.path}; "
-    s.send("sink ed default command='#{pf}#@cmd'", Socket::MSG_EOR)
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("sink ed default command='#{pf}#@cmd'")
 
     # make a sleepy sink trickle, too
     sleepy_pid = Tempfile.new(%w(dtas-test .pid))
     pf = "echo $$ >> #{sleepy_pid.path};"
-    s.send("sink ed sleepy command='#{pf}#@cmd' active=true", Socket::MSG_EOR)
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("sink ed sleepy command='#{pf}#@cmd' active=true")
 
     # ensure both sinks were created
-    s.send("sink ls", Socket::MSG_EOR)
-    assert_equal "default sleepy", s.readpartial(666)
+    res = s.req("sink ls")
+    assert_equal "default sleepy", res
 
     # generate pinknoise
     pinknoise = "sox -n -r 44100 -c 2 -t s32 - synth 0 pinknoise"
-    s.send("enq-cmd \"#{pinknoise}\"", Socket::MSG_EOR)
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("enq-cmd \"#{pinknoise}\"")
 
     # wait for sinks to start
     wait_files_not_empty(sleepy_pid, default_pid)
@@ -80,8 +75,7 @@ class TestPlayerIntegration < Minitest::Unit::TestCase
     sleepy = File.read(sleepy_pid).to_i
     assert_operator sleepy, :>, 0
     Process.kill(0, sleepy)
-    s.send("sink ed sleepy active=false", Socket::MSG_EOR)
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("sink ed sleepy active=false")
     wait_pid_dead(sleepy)
 
     # ensure default sink is still alive
@@ -93,8 +87,7 @@ class TestPlayerIntegration < Minitest::Unit::TestCase
     sleepy_pid.sync = true
     sleepy_pid.seek(0)
     sleepy_pid.truncate(0)
-    s.send("sink ed sleepy active=true", Socket::MSG_EOR)
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("sink ed sleepy active=true")
 
     # wait for sleepy sink
     wait_files_not_empty(sleepy_pid)
@@ -105,8 +98,7 @@ class TestPlayerIntegration < Minitest::Unit::TestCase
     Process.kill(0, sleepy)
 
     # stop playing current track
-    s.send("skip", Socket::MSG_EOR)
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("skip")
 
     wait_pid_dead(sleepy)
     wait_pid_dead(default)
@@ -115,22 +107,17 @@ class TestPlayerIntegration < Minitest::Unit::TestCase
   def test_env_change
     s = client_socket
     tmp = Tempfile.new(%w(env .txt))
-    s.preq("sink ed default active=true command='cat >/dev/null'")
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("sink ed default active=true command='cat >/dev/null'")
 
-    s.preq("env FOO=BAR")
-    assert_equal "OK", s.readpartial(666)
-    s.preq(["enq-cmd", "echo $FOO | tee #{tmp.path}"])
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("env FOO=BAR")
+    s.req_ok(["enq-cmd", "echo $FOO | tee #{tmp.path}"])
     wait_files_not_empty(tmp)
     assert_equal "BAR\n", tmp.read
 
     tmp.rewind
     tmp.truncate(0)
-    s.preq("env FOO#")
-    assert_equal "OK", s.readpartial(666)
-    s.preq(["enq-cmd", "echo -$FOO- | tee #{tmp.path}"])
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("env FOO#")
+    s.req_ok(["enq-cmd", "echo -$FOO- | tee #{tmp.path}"])
     wait_files_not_empty(tmp)
     assert_equal "--\n", tmp.read
   end
@@ -138,31 +125,25 @@ class TestPlayerIntegration < Minitest::Unit::TestCase
   def test_sink_env
     s = client_socket
     tmp = Tempfile.new(%w(env .txt))
-    s.preq("sink ed default active=true command='echo -$FOO- > #{tmp.path}'")
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("sink ed default active=true command='echo -$FOO- > #{tmp.path}'")
 
-    s.preq("sink ed default env.FOO=BAR")
-    assert_equal "OK", s.readpartial(666)
-    s.preq(["enq-cmd", "echo HI"])
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("sink ed default env.FOO=BAR")
+    s.req_ok(["enq-cmd", "echo HI"])
     wait_files_not_empty(tmp)
     assert_equal "-BAR-\n", tmp.read
 
     tmp.rewind
     tmp.truncate(0)
-    s.preq("sink ed default env#FOO")
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("sink ed default env#FOO")
 
     Timeout.timeout(5) do
       begin
-        s.preq("current")
-        yaml = s.readpartial(66666)
+        yaml = s.req("current")
         cur = YAML.load(yaml)
       end while cur["sinks"] && sleep(0.01)
     end
 
-    s.preq(["enq-cmd", "echo HI"])
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok(["enq-cmd", "echo HI"])
     wait_files_not_empty(tmp)
     assert_equal "--\n", tmp.read
   end
@@ -171,15 +152,11 @@ class TestPlayerIntegration < Minitest::Unit::TestCase
     s = client_socket
     default_sink_pid(s)
     dump = Tempfile.new(%W(d .sox))
-    s.preq "sink ed dump active=true command='sox $SOXFMT - #{dump.path}'"
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok "sink ed dump active=true command='sox $SOXFMT - #{dump.path}'"
     noise, len = tmp_noise
-    s.preq("enq-head #{noise.path}")
-    assert_equal "OK", s.readpartial(666)
-    s.preq("enq-head #{noise.path} 4")
-    assert_equal "OK", s.readpartial(666)
-    s.preq("enq-head #{noise.path} 3")
-    assert_equal "OK", s.readpartial(666)
+    s.req_ok("enq-head #{noise.path}")
+    s.req_ok("enq-head #{noise.path} 4")
+    s.req_ok("enq-head #{noise.path} 3")
     dethrottle_decoder(s)
     expect = Tempfile.new(%W(expect .sox))
 
@@ -188,8 +165,7 @@ class TestPlayerIntegration < Minitest::Unit::TestCase
     assert system(c)
     Timeout.timeout(len) do
       begin
-        s.preq("current")
-        yaml = s.readpartial(66666)
+        yaml = s.req("current")
         cur = YAML.load(yaml)
       end while cur["sinks"] && sleep(0.01)
     end
@@ -201,20 +177,32 @@ class TestPlayerIntegration < Minitest::Unit::TestCase
     s = client_socket
     pwd = Dir.pwd
 
-    s.preq("pwd")
-    assert_equal pwd, s.readpartial(6666)
+    assert_equal pwd, s.req("pwd")
 
-    s.preq("cd /")
-    assert_equal "OK", s.readpartial(6)
+    s.req_ok("cd /")
 
-    s.preq("pwd")
-    assert_equal "/", s.readpartial(6)
+    assert_equal "/", s.req("pwd")
 
-    s.preq("cd /this-better-be-totally-non-existent-on-any-system-#{rand}")
-    err = s.readpartial(666)
+    err = s.req("cd /this-better-be-totally-non-existent-on-any-system-#{rand}")
     assert_match(%r{\AERR }, err, err)
 
-    s.preq("pwd")
-    assert_equal "/", s.readpartial(6)
+    assert_equal "/", s.req("pwd")
+  end
+
+  def test_source_ed
+    s = client_socket
+    assert_equal "sox av ff", s.req("source ls")
+    s.req_ok("source ed av tryorder=-1")
+    assert_equal "av sox ff", s.req("source ls")
+    s.req_ok("source ed av tryorder=")
+    assert_equal "sox av ff", s.req("source ls")
+
+    s.req_ok("source ed sox command=true")
+    sox = YAML.load(s.req("source cat sox"))
+    assert_equal "true", sox["command"]
+
+    s.req_ok("source ed sox command=")
+    sox = YAML.load(s.req("source cat sox"))
+    assert_equal DTAS::Source::Sox::SOX_DEFAULTS["command"], sox["command"]
   end
 end