dtas 0.0.0

data/bin/dtas-xdelay

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+USAGE = "Usage: #$0 [-x FREQ] [-l] /dev/fd/LO /dev/fd/HI DELAY [DELAY ...]"
+require 'optparse'
+dryrun = false
+xover = '80'
+delay_lo = []
+delay_hi = []
+adj_delay = delay_hi
+out_channels = out_rate = out_type = nil
+
+lowpass = 'lowpass %s lowpass %s'
+highpass = 'highpass %s highpass %s'
+
+op = OptionParser.new('', 24, '  ') do |opts|
+  opts.banner = USAGE
+  opts.on('-x', '--crossover-frequency FREQ') do |freq|
+    xover = freq
+  end
+  opts.on('-l', '--lowpass-delay') { adj_delay = delay_lo }
+  opts.on('-c', '--channels INTEGER') { |val| out_channels = val }
+  opts.on('-r', '--rate RATE') { |val| out_rate = val }
+  opts.on('-t', '--type FILE-TYPE') { |val| out_type = val }
+  opts.on('-n', '--dry-run') { dryrun = true }
+  opts.on('--lowpass FORMAT_STRING') { |s| lowpass = s }
+  opts.on('--highpass FORMAT_STRING') { |s| highpass = s }
+  opts.parse!(ARGV)
+end
+
+dev_fd_lo = ARGV.shift
+dev_fd_hi = ARGV.shift
+if ARGV.delete('-')
+  # we re-add the '-' below
+  out_channels && out_rate && out_type or
+    abort "-c, -r, and -t must all be specified for standard output"
+  cmd = "sox"
+elsif out_channels || out_rate || out_type
+  abort "standard output (`-') must be specified with -c, -r, or -t"
+else
+  cmd = "play"
+end
+soxfmt = ENV["SOXFMT"] or abort "#$0 SOXFMT undefined"
+
+# configure the sox "delay" effect
+delay = ARGV.dup
+delay[0] or abort USAGE
+channels = ENV['CHANNELS'] or abort "#$0 CHANNELS env must be set"
+channels = channels.to_i
+adj_delay.replace(delay.dup)
+until adj_delay.size == channels
+  adj_delay << delay.last
+end
+adj_delay.unshift("delay")
+
+# prepare two inputs:
+delay_lo = delay_lo.join(' ')
+delay_hi = delay_hi.join(' ')
+
+lowpass_args = []
+lowpass.gsub('%s') { |s| lowpass_args << xover; s }
+highpass_args = []
+highpass.gsub('%s') { |s| highpass_args << xover; s }
+
+lo = "|exec sox #{soxfmt} #{dev_fd_lo} -p " \
+     "#{sprintf(lowpass, *lowpass_args)} #{delay_lo}".strip
+hi = "|exec sox #{soxfmt} #{dev_fd_hi} -p " \
+     "#{sprintf(highpass, *highpass_args)} #{delay_hi}".strip
+
+args = [ "-m", "-v1", lo, "-v1", hi ]
+case cmd
+when "sox"
+  args.unshift "sox"
+  args.concat(%W(-t#{out_type} -c#{out_channels} -r#{out_rate} -))
+when "play"
+  args.unshift "play"
+else
+  abort "BUG: bad cmd=#{cmd.inspect}"
+end
+if dryrun
+  p args
+else
+  exec *args, close_others: false
+end

data/dtas-linux.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: binary -*-
+# this just declares dependencies to make gem installation a little easier
+# for Linux users
+Gem::Specification.new do |s|
+  s.name = %q{dtas-linux}
+  s.version = '1.0.0'
+  s.authors = ["dtas hackers"]
+  s.summary = "meta-package for dtas users on the Linux kernel"
+  s.description = "gives small performance improvements for dtas users\n" \
+                  "via tee(), splice() and eventfd() on Linux"
+  s.email = %q{e@80x24.org}
+  s.files = []
+  s.homepage = 'http://dtas.80x24.org/'
+  s.add_dependency(%q<dtas>)
+  s.add_dependency(%q<io_splice>, '~> 4')
+  s.add_dependency(%q<sleepy_penguin>, '~> 3')
+  s.licenses = "GPLv3+"
+end

data/dtas-mpris.gemspec

@@ -0,0 +1,16 @@
+# -*- encoding: binary -*-
+Gem::Specification.new do |s|
+  s.name = %q{dtas-mpris}
+  s.version = '0.0.0'
+  s.authors = ["dtas hackers"]
+  s.summary = "meta-package for the dtas-mpris proxy"
+  s.description =
+    "this allows controlling dtas-player via MPRIS or MPRIS 2.0\n" \
+    "This is currently a dummy package as dtas-mpris is not implemented"
+  s.email = %q{e@80x24.org}
+  s.files = []
+  s.homepage = 'http://dtas.80x24.org/'
+  s.add_dependency(%q<dtas>)
+  s.add_dependency(%q<ruby-dbus>)
+  s.licenses = "GPLv2+"
+end

data/examples/dtas_state.yml

@@ -0,0 +1,18 @@
+---
+socket: .dtas/player.sock
+sinks:
+- name: ODAC
+  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
+  env:
+    SINK_BITS: 24
+    SINK_RATE: 44100
+    SINK_CHANNELS: 2
+- name: play
+  prio: -2
+  command: env AUDIODEV=hw:DAC play -t $SOX_FILETYPE -r $RATE -c $CHANNELS -

data/lib/dtas.rb

@@ -0,0 +1,7 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+module DTAS # :nodoc:
+end
+
+require 'dtas/compat_onenine'

data/lib/dtas/buffer.rb

@@ -0,0 +1,90 @@
+# -*- 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'
+
+class DTAS::Buffer # :nodoc:
+  begin
+    raise LoadError, "no splice with _DTAS_POSIX" if ENV["_DTAS_POSIX"]
+    require 'io/splice' # splice is only in Linux for now...
+    require_relative 'buffer/splice'
+    include DTAS::Buffer::Splice
+  rescue LoadError
+    require_relative 'buffer/read_write'
+    include DTAS::Buffer::ReadWrite
+  end
+
+  attr_reader :to_io # call nread on this
+  attr_reader :wr # processes (sources) should redirect to this
+  attr_accessor :bytes_xfer
+
+  def initialize
+    @bytes_xfer = 0
+    @buffer_size = nil
+    @to_io, @wr = DTAS::Pipe.new
+  end
+
+  def self.load(hash)
+    buf = new
+    if hash
+      bs = hash["buffer_size"] and buf.buffer_size = bs
+    end
+    buf
+  end
+
+  def to_hsh
+    @buffer_size ? { "buffer_size" => @buffer_size } : {}
+  end
+
+  def __dst_error(dst, e)
+    warn "dropping #{dst.inspect} due to error: #{e.message} (#{e.class})"
+    dst.close unless dst.closed?
+  end
+
+  # This will modify targets
+  # returns one of:
+  # - :wait_readable
+  # - subset of targets array for :wait_writable
+  # - some type of StandardError
+  # - nil
+  def broadcast(targets)
+    bytes = inflight
+    return :wait_readable if 0 == bytes # spurious wakeup
+
+    case targets.size
+    when 0
+      :ignore # this will pause decoders
+    when 1
+      broadcast_one(targets, bytes)
+    else # infinity
+      broadcast_inf(targets, bytes)
+    end
+  end
+
+  def readable_iter
+    # this calls DTAS::Buffer#broadcast from DTAS::Player
+    yield(self, nil)
+  end
+
+  def inflight
+    @to_io.nread
+  end
+
+  # don't really close the pipes under normal circumstances, just clear data
+  def close
+    bytes = inflight
+    discard(bytes) if bytes > 0
+  end
+
+  def buf_reset
+    close!
+    @bytes_xfer = 0
+    @to_io, @wr = DTAS::Pipe.new
+    @wr.pipe_size = @buffer_size if @buffer_size
+  end
+
+  def close!
+    @to_io.close
+    @wr.close
+  end
+end

data/lib/dtas/buffer/read_write.rb

@@ -0,0 +1,102 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require 'io/wait'
+require 'io/nonblock'
+require_relative '../../dtas'
+require_relative '../pipe'
+
+module DTAS::Buffer::ReadWrite # :nodoc:
+  MAX_AT_ONCE = 512 # min PIPE_BUF value in POSIX
+  attr_accessor :buffer_size
+
+  def _rbuf
+    Thread.current[:dtas_pbuf] ||= ""
+  end
+
+  # be sure to only call this with nil when all writers to @wr are done
+  def discard(bytes)
+    buf = _rbuf
+    begin
+      @to_io.read(bytes, buf) or break # EOF
+      bytes -= buf.bytesize
+    end until bytes == 0
+  end
+
+  # always block when we have a single target
+  def broadcast_one(targets, bytes)
+    buf = _rbuf
+    @to_io.read(bytes, buf)
+    n = targets[0].write(buf) # IO#write has write-in-full behavior
+    @bytes_xfer += n
+    :wait_readable
+  rescue Errno::EPIPE, IOError => e
+    __dst_error(targets[0], e)
+    targets.clear
+    nil # do not return error here, we already spewed an error message
+  end
+
+  def broadcast_inf(targets, bytes)
+    nr_nb = targets.count { |sink| sink.nonblock? }
+    if nr_nb == 0 || nr_nb == targets.size
+      # if all targets are full, don't start until they're all writable
+      r = IO.select(nil, targets, nil, 0) or return targets
+      blocked = targets - r[1]
+
+      # tell DTAS::UNIXServer#run_once to wait on the blocked targets
+      return blocked if blocked[0]
+
+      # all writable, yay!
+    else
+      blocked = []
+    end
+
+    again = {}
+
+    # don't pin too much on one target
+    bytes = bytes > MAX_AT_ONCE ? MAX_AT_ONCE : bytes
+    buf = _rbuf
+    @to_io.read(bytes, buf)
+    @bytes_xfer += buf.bytesize
+
+    targets.delete_if do |dst|
+      begin
+        if dst.nonblock?
+          w = dst.write_nonblock(buf)
+          again[dst] = buf.byteslice(w, n) if w < n
+        else
+          dst.write(buf)
+        end
+        false
+      rescue Errno::EAGAIN
+        blocked << dst
+        false
+      rescue IOError, Errno::EPIPE => e
+        again.delete(dst)
+        __dst_error(dst, e)
+        true
+      end
+    end
+
+    # try to write as much as possible
+    again.delete_if do |dst, sbuf|
+      begin
+        w = dst.write_nonblock(sbuf)
+        n = sbuf.bytesize
+        if w < n
+          again[dst] = sbuf.byteslice(w, n)
+          false
+        else
+          true
+        end
+      rescue Errno::EAGAIN
+        blocked << dst
+        true
+      rescue IOError, Errno::EPIPE => e
+        __dst_error(dst, e)
+        true
+      end
+    end until again.empty?
+    targets[0] ? :wait_readable : nil
+  end
+end

data/lib/dtas/buffer/splice.rb

@@ -0,0 +1,142 @@
+# -*- encoding: binary -*-
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net>
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require 'io/wait'
+require 'io/nonblock'
+require 'io/splice'
+require_relative '../../dtas'
+require_relative '../pipe'
+
+module DTAS::Buffer::Splice # :nodoc:
+  MAX_AT_ONCE = 4096 # page size in Linux
+  MAX_SIZE = File.read("/proc/sys/fs/pipe-max-size").to_i
+  DEVNULL = File.open("/dev/null", "r+")
+  F_MOVE = IO::Splice::F_MOVE
+  WAITALL = IO::Splice::WAITALL
+
+  def buffer_size
+    @to_io.pipe_size
+  end
+
+  # nil is OK, won't reset existing pipe, either...
+  def buffer_size=(bytes)
+    @to_io.pipe_size = bytes if bytes
+    @buffer_size = bytes
+  end
+
+  # be sure to only call this with nil when all writers to @wr are done
+  def discard(bytes)
+    IO.splice(@to_io, nil, DEVNULL, nil, bytes)
+  end
+
+  def broadcast_one(targets, bytes)
+    # single output is always non-blocking
+    s = IO.trysplice(@to_io, nil, targets[0], nil, bytes, F_MOVE)
+    if Symbol === s
+      targets # our one and only target blocked on write
+    else
+      @bytes_xfer += s
+      :wait_readable # we want to read more from @to_io soon
+    end
+  rescue Errno::EPIPE, IOError => e
+    __dst_error(targets[0], e)
+    targets.clear
+    nil # do not return error here, we already spewed an error message
+  end
+
+  # returns the largest value we teed
+  def __broadcast_tee(blocked, targets, chunk_size)
+    most_teed = 0
+    targets.delete_if do |dst|
+      begin
+        t = dst.nonblock? ?
+            IO.trytee(@to_io, dst, chunk_size) :
+            IO.tee(@to_io, dst, chunk_size, WAITALL)
+        if Integer === t
+          most_teed = t if t > most_teed
+        else
+          blocked << dst
+        end
+        false
+      rescue IOError, Errno::EPIPE => e
+        __dst_error(dst, e)
+        true
+      end
+    end
+    most_teed
+  end
+
+  def broadcast_inf(targets, bytes)
+    if targets.none? { |sink| sink.nonblock? }
+      # if all targets are blocking, don't start until they're all writable
+      r = IO.select(nil, targets, nil, 0) or return targets
+      blocked = targets - r[1]
+
+      # tell DTAS::UNIXServer#run_once to wait on the blocked targets
+      return blocked if blocked[0]
+
+      # all writable, yay!
+    else
+      blocked = []
+    end
+
+    # don't pin too much on one target
+    bytes = bytes > MAX_AT_ONCE ? MAX_AT_ONCE : bytes
+
+    last = targets.pop # we splice to the last one, tee to the rest
+    most_teed = __broadcast_tee(blocked, targets, bytes)
+
+    # don't splice more than the largest amount we successfully teed
+    bytes = most_teed if most_teed > 0
+
+    begin
+      targets << last
+      if last.nonblock?
+        s = IO.trysplice(@to_io, nil, last, nil, bytes, F_MOVE)
+        if Symbol === s
+          blocked << last
+
+          # we accomplished nothing!
+          # If _all_ writers are blocked, do not discard data,
+          # stay blocked on :wait_writable
+          return blocked if most_teed == 0
+
+          # the tees targets win, drop data intended for last
+          if most_teed > 0
+            discard(most_teed)
+            @bytes_xfer += most_teed
+            # do not watch for writability of last, last is non-blocking
+            return :wait_readable
+          end
+        end
+      else
+        # the blocking case is simple
+        s = IO.splice(@to_io, nil, last, nil, bytes, WAITALL|F_MOVE)
+      end
+      @bytes_xfer += s
+
+      # if we can't splice everything
+      # discard it so the early targets do not get repeated data
+      if s < bytes && most_teed > 0
+        discard(bytes - s)
+      end
+      :wait_readable
+    rescue IOError, Errno::EPIPE => e # last failed, drop it
+      __dst_error(last, e)
+      targets.pop # we're no longer a valid target
+
+      if most_teed == 0
+        # nothing accomplished, watch any targets
+        return blocked if blocked[0]
+      else
+        # some progress, discard the data we could not splice
+        @bytes_xfer += most_teed
+        discard(most_teed)
+      end
+
+      # stop decoding if we're completely errored out
+      # returning nil will trigger close
+      return targets[0] ? :wait_readable : nil
+    end
+  end
+end