dtas 0.0.0

data/test/test_format_change.rb

@@ -0,0 +1,49 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require './test/player_integration'
+require 'tmpdir'
+class TestFormatChange < Minitest::Unit::TestCase
+  include PlayerIntegration
+
+  def test_format_change
+    s = client_socket
+    default_pid = default_sink_pid(s)
+    Dir.mktmpdir do |dir|
+      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)
+      noise, len = tmp_noise
+      s.preq(%W(enq #{noise.path}))
+      assert_equal "OK", s.readpartial(666)
+      wait_files_not_empty(default_pid, f44100)
+
+      s.preq("format rate=88200")
+      assert_equal "OK", s.readpartial(666)
+
+      wait_files_not_empty(f88200)
+
+      dethrottle_decoder(s)
+
+      Timeout.timeout(len) do
+        begin
+          s.preq("current")
+          cur = YAML.load(s.readpartial(6666))
+        end while cur["sinks"] && sleep(0.01)
+      end
+
+      c = "sox -R -ts32 -c2 -r88200 #{dir}/dump.2.88200 " \
+          "-ts32 -c2 -r44100 #{dir}/part2"
+      assert(system(c), c)
+
+      c = "sox -R -ts32 -c2 -r44100 #{dir}/dump.2.44100 " \
+          "-ts32 -c2 -r44100 #{dir}/part2 #{dir}/res.sox"
+      assert(system(c), c)
+
+      assert_equal `soxi -s #{dir}/res.sox`, `soxi -s #{noise.path}`
+      File.unlink(*Dir["#{dir}/*"].to_a)
+    end
+  end
+end

data/test/test_player.rb

@@ -0,0 +1,47 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require './test/helper'
+require 'tempfile'
+require 'dtas/player'
+
+class TestPlayer < Minitest::Unit::TestCase
+  def setup
+    @player = nil
+    tmp = Tempfile.new(%w(dtas-player-test .sock))
+    @path = tmp.path
+    File.unlink(@path)
+  end
+
+  def teardown
+    @player.close if @player
+  end
+
+  def test_player_new
+    player = DTAS::Player.new
+    player.socket = @path
+    player.bind
+    assert File.socket?(@path)
+  ensure
+    player.close
+    refute File.socket?(@path)
+  end
+
+  def test_player_serialize
+    @player = DTAS::Player.new
+    @player.socket = @path
+    @player.bind
+    hash = @player.to_hsh
+    assert_equal({"socket" => @path}, hash)
+  end
+
+  def test_player_serialize_format
+    fmt = DTAS::Format.new
+    fmt.type = "f32"
+    fmt.rate = 48000
+    player = DTAS::Player.load("format" => fmt.to_hsh)
+    fhash = player.to_hsh["format"]
+    assert_equal "f32", fhash["type"]
+    assert_equal 48000, fhash["rate"]
+  end
+end

data/test/test_player_client_handler.rb

@@ -0,0 +1,86 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require './test/helper'
+require 'dtas/player'
+
+class TestPlayerClientHandler < Minitest::Unit::TestCase
+  class MockIO < Array
+    alias emit push
+  end
+
+  include DTAS::Player::ClientHandler
+
+  def setup
+    @sinks = {}
+    @io = MockIO.new
+    @srv = nil # unused mock
+  end
+
+  def test_delete
+    @sinks["default"] = DTAS::Sink.new
+    @targets = []
+    sink_handler(@io, %w(rm default))
+    assert @sinks.empty?
+    assert_equal %w(OK), @io.to_a
+  end
+
+  def test_delete_noexist
+    sink_handler(@io, %w(rm default))
+    assert @sinks.empty?
+    assert_equal ["ERR default not found"], @io.to_a
+  end
+
+  def test_env
+    sink_handler(@io, %w(ed default env.FOO=bar))
+    assert_equal "bar", @sinks["default"].env["FOO"]
+    sink_handler(@io, %w(ed default env.FOO=))
+    assert_equal "", @sinks["default"].env["FOO"]
+    sink_handler(@io, %w(ed default env#FOO))
+    assert_nil @sinks["default"].env["FOO"]
+  end
+
+  def test_sink_ed
+    command = 'sox -t $SOX_FILETYPE -r $RATE -c $CHANNELS - \
+      -t s$SINK_BITS -r $SINK_RATE -c $SINK_CHANNELS - | \
+    aplay -D hw:DAC_1 -v -q -M --buffer-size=500000 --period-size=500 \
+      --disable-softvol --start-delay=100 \
+      --disable-format --disable-resample --disable-channels \
+      -t raw -c $SINK_CHANNELS -f S${SINK_BITS}_3LE -r $SINK_RATE
+    '
+    sink_handler(@io, %W(ed foo command=#{command}))
+    assert_equal command, @sinks["foo"].command
+    assert_empty @sinks["foo"].env
+    sink_handler(@io, %W(ed foo env.SINK_BITS=24))
+    sink_handler(@io, %W(ed foo env.SINK_CHANNELS=2))
+    sink_handler(@io, %W(ed foo env.SINK_RATE=48000))
+    expect = {
+      "SINK_BITS" => "24",
+      "SINK_CHANNELS" => "2",
+      "SINK_RATE" => "48000",
+    }
+    assert_equal expect, @sinks["foo"].env
+    @io.all? { |s| assert_equal "OK", s }
+    assert_equal 4, @io.size
+  end
+
+  def test_cat
+    sink = DTAS::Sink.new
+    sink.name = "default"
+    sink.command += "dither -s"
+    @sinks["default"] = sink
+    sink_handler(@io, %W(cat default))
+    assert_equal 1, @io.size
+    hsh = YAML.load(@io[0])
+    assert_kind_of Hash, hsh
+    assert_equal "default", hsh["name"]
+    assert_match("dither -s", hsh["command"])
+  end
+
+  def test_ls
+    expect = %w(a b c d)
+    expect.each { |s| @sinks[s] = true }
+    sink_handler(@io, %W(ls))
+    assert_equal expect, Shellwords.split(@io[0])
+  end
+end

data/test/test_player_integration.rb

@@ -0,0 +1,220 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require './test/player_integration'
+class TestPlayerIntegration < Minitest::Unit::TestCase
+  include PlayerIntegration
+
+  def test_cmd_rate
+    pid = fork do
+      @fmt.to_env.each { |k,v| ENV[k] = v }
+      exec("sox -n $SOXFMT - synth 3 pinknoise | #@cmd")
+    end
+    t = Time.now
+    _, _ = Process.waitpid2(pid)
+    elapsed = Time.now - t
+    assert_in_delta 3.0, elapsed, 0.5
+  end if ENV["MATH_IS_HARD"] # ensure our @cmd timing is accurate
+
+  def test_sink_close_after_play
+    s = client_socket
+    @cmd = "cat >/dev/null"
+    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)
+      wait_files_not_empty(junk)
+      assert_equal "OK", s.readpartial(666)
+    end
+    wait_files_not_empty(default_pid)
+    pid = read_pid_file(default_pid)
+    wait_pid_dead(pid)
+  end
+
+  def test_sink_killed_during_play
+    s = client_socket
+    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)
+    wait_files_not_empty(cmd, default_pid)
+    pid = read_pid_file(default_pid)
+    Process.kill(:KILL, pid)
+    cmd_pid = read_pid_file(cmd)
+    wait_pid_dead(cmd_pid)
+  end
+
+  def test_sink_activate
+    s = client_socket
+    s.send("sink ls", Socket::MSG_EOR)
+    assert_equal "default", s.readpartial(666)
+
+    # 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)
+
+    # 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)
+
+    # ensure both sinks were created
+    s.send("sink ls", Socket::MSG_EOR)
+    assert_equal "default sleepy", s.readpartial(666)
+
+    # 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)
+
+    # wait for sinks to start
+    wait_files_not_empty(sleepy_pid, default_pid)
+
+    # deactivate sleepy sink and ensure it's gone
+    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)
+    wait_pid_dead(sleepy)
+
+    # ensure default sink is still alive
+    default = File.read(default_pid).to_i
+    assert_operator default, :>, 0
+    Process.kill(0, default)
+
+    # restart sleepy sink
+    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)
+
+    # wait for sleepy sink
+    wait_files_not_empty(sleepy_pid)
+
+    # check sleepy restarted
+    sleepy = File.read(sleepy_pid).to_i
+    assert_operator sleepy, :>, 0
+    Process.kill(0, sleepy)
+
+    # stop playing current track
+    s.send("skip", Socket::MSG_EOR)
+    assert_equal "OK", s.readpartial(666)
+
+    wait_pid_dead(sleepy)
+    wait_pid_dead(default)
+  end
+
+  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.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)
+    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)
+    wait_files_not_empty(tmp)
+    assert_equal "--\n", tmp.read
+  end
+
+  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.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)
+    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)
+
+    Timeout.timeout(5) do
+      begin
+        s.preq("current")
+        yaml = s.readpartial(66666)
+        cur = YAML.load(yaml)
+      end while cur["sinks"] && sleep(0.01)
+    end
+
+    s.preq(["enq-cmd", "echo HI"])
+    assert_equal "OK", s.readpartial(666)
+    wait_files_not_empty(tmp)
+    assert_equal "--\n", tmp.read
+  end
+
+  def test_enq_head
+    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)
+    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)
+    dethrottle_decoder(s)
+    expect = Tempfile.new(%W(expect .sox))
+
+    c = "sox #{noise.path} -t sox '|sox #{noise.path} -p trim 3' " \
+            "-t sox '|sox #{noise.path} -p trim 4' #{expect.path}"
+    assert system(c)
+    Timeout.timeout(len) do
+      begin
+        s.preq("current")
+        yaml = s.readpartial(66666)
+        cur = YAML.load(yaml)
+      end while cur["sinks"] && sleep(0.01)
+    end
+    assert(system("cmp", dump.path, expect.path),
+           "files don't match #{dump.path} != #{expect.path}")
+  end
+
+  def test_cd_pwd
+    s = client_socket
+    pwd = Dir.pwd
+
+    s.preq("pwd")
+    assert_equal pwd, s.readpartial(6666)
+
+    s.preq("cd /")
+    assert_equal "OK", s.readpartial(6)
+
+    s.preq("pwd")
+    assert_equal "/", s.readpartial(6)
+
+    s.preq("cd /this-better-be-totally-non-existent-on-any-system-#{rand}")
+    err = s.readpartial(666)
+    assert_match(%r{\AERR }, err, err)
+
+    s.preq("pwd")
+    assert_equal "/", s.readpartial(6)
+  end
+end

data/test/test_rg_integration.rb

@@ -0,0 +1,117 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require './test/player_integration'
+class TestRgIntegration < Minitest::Unit::TestCase
+  include PlayerIntegration
+
+  def tmp_pluck(len = 5)
+    pluck = Tempfile.open(%w(pluck .flac))
+    cmd = %W(sox -R -n -r44100 -c2 -C0 #{pluck.path} synth #{len} pluck)
+    assert system(*cmd), cmd
+    cmd = %W(metaflac
+             --set-tag=REPLAYGAIN_TRACK_GAIN=-2
+             --set-tag=REPLAYGAIN_ALBUM_GAIN=-3.0
+             --set-tag=REPLAYGAIN_TRACK_PEAK=0.666
+             --set-tag=REPLAYGAIN_ALBUM_PEAK=0.999
+             #{pluck.path})
+    assert system(*cmd), cmd
+    [ pluck, len ]
+  end
+
+  def test_rg_changes_added
+    s = client_socket
+    pluck, len = tmp_pluck
+
+    # create the default sink, as well as a dumper
+    dumper = Tempfile.open(%w(dump .sox))
+    dump_pid = Tempfile.new(%w(dump .pid))
+    default_pid = default_sink_pid(s)
+    dump_cmd = "echo $$ > #{dump_pid.path}; sox $SOXFMT - #{dumper.path}"
+    s.send("sink ed dump active=true command='#{dump_cmd}'", Socket::MSG_EOR)
+    assert_equal("OK", s.readpartial(666))
+
+    # start playback!
+    s.send("enq \"#{pluck.path}\"", Socket::MSG_EOR)
+    assert_equal "OK", s.readpartial(666)
+
+    # wait for playback to start
+    yaml = cur = nil
+    Timeout.timeout(5) do
+      begin
+        s.send("current", Socket::MSG_EOR)
+        cur = YAML.load(yaml = s.readpartial(1666))
+      end while cur["current_offset"] == 0 && sleep(0.01)
+    end
+
+    assert_nil cur["current"]["env"]["RGFX"]
+
+    assert_equal DTAS::Format.new.rate * len, cur["current_expect"]
+
+    wait_files_not_empty(dump_pid)
+    pid = read_pid_file(dump_pid)
+
+    check_gain = proc do |expect, mode|
+      s.send("rg mode=#{mode}", Socket::MSG_EOR)
+      assert_equal "OK", s.readpartial(666)
+      Timeout.timeout(5) do
+        begin
+          s.send("current", Socket::MSG_EOR)
+          cur = YAML.load(yaml = s.readpartial(3666))
+        end while cur["current"]["env"]["RGFX"] !~ expect && sleep(0.01)
+      end
+      assert_match expect, cur["current"]["env"]["RGFX"]
+    end
+
+    check_gain.call(%r{vol -3dB}, "album_gain")
+    check_gain.call(%r{vol -2dB}, "track_gain")
+    check_gain.call(%r{vol 1\.3}, "track_peak")
+    check_gain.call(%r{vol 1\.0}, "album_peak")
+
+    s.send("rg preamp+=1", Socket::MSG_EOR)
+    assert_equal "OK", s.readpartial(666)
+    s.send("rg", Socket::MSG_EOR)
+    rg = YAML.load(yaml = s.readpartial(3666))
+    assert_equal 1, rg["preamp"]
+
+    s.send("rg preamp-=1", Socket::MSG_EOR)
+    assert_equal "OK", s.readpartial(666)
+    s.send("rg", Socket::MSG_EOR)
+    rg = YAML.load(yaml = s.readpartial(3666))
+    assert_nil rg["preamp"]
+
+    s.send("rg preamp=2", Socket::MSG_EOR)
+    assert_equal "OK", s.readpartial(666)
+    s.send("rg", Socket::MSG_EOR)
+    rg = YAML.load(yaml = s.readpartial(3666))
+    assert_equal 2, rg["preamp"]
+
+    s.send("rg preamp-=0.3", Socket::MSG_EOR)
+    assert_equal "OK", s.readpartial(666)
+    s.send("rg", Socket::MSG_EOR)
+    rg = YAML.load(yaml = s.readpartial(3666))
+    assert_equal 1.7, rg["preamp"]
+
+    s.send("rg preamp-=-0.3", Socket::MSG_EOR)
+    assert_equal "OK", s.readpartial(666)
+    s.send("rg", Socket::MSG_EOR)
+    rg = YAML.load(yaml = s.readpartial(3666))
+    assert_equal 2.0, rg["preamp"]
+
+    s.send("rg preamp-=+0.3", Socket::MSG_EOR)
+    assert_equal "OK", s.readpartial(666)
+    s.send("rg", Socket::MSG_EOR)
+    rg = YAML.load(yaml = s.readpartial(3666))
+    assert_equal 1.7, rg["preamp"]
+
+    dethrottle_decoder(s)
+
+    # ensure we did not change audio length
+    wait_pid_dead(pid, len)
+    samples = `soxi -s #{dumper.path}`.to_i
+    assert_equal cur["current_expect"], samples
+    assert_equal `soxi -d #{dumper.path}`, `soxi -d #{pluck.path}`
+
+    stop_playback(default_pid, s)
+  end
+end