dtas 0.14.2 → 0.15.0

data/lib/dtas/fadefx.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2013-2016 all contributors <dtas-all@nongnu.org>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
 require_relative '../dtas'
 require_relative 'parse_time'
@@ -95,7 +95,7 @@ def fade_in_next_fx(format, tbeg, tlen)
   def parse!(str)
     return nil if str.empty?
     type = "t"
-    str.sub!(/\A([a-z])/, "") and type = $1.freeze
+    str.sub!(/\A([a-z])/, "") and type = DTAS.dedupe_str($1)
     F.new(type, parse_time(str))
   end
 end

data/lib/dtas/format.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2013-2016 all contributors <dtas-all@nongnu.org>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
 require_relative '../dtas'
 require_relative 'process'
@@ -56,10 +56,14 @@ def self.precision(env, infile)
 
   def self.from_file(env, infile)
     fmt = new
-    fmt.channels = qx(env, %W(soxi -c #{infile})).to_i
-    fmt.type = qx(env, %W(soxi -t #{infile})).strip
-    fmt.rate = qx(env, %W(soxi -r #{infile})).to_i
-    fmt.bits ||= precision(env, infile)
+    out = qx(env, %W(soxi #{infile}), err: DTAS.null)
+    out =~ /^Channels\s*:\s*(\d+)/n
+    fmt.channels = $1.to_i
+    out =~ /^Sample Rate\s*:\s*(\d+)/n
+    fmt.rate = $1.to_i
+    out =~ /Precision\s*:\s*(\d+)-bit/n
+    fmt.bits = $1.to_i
+    fmt.type = qx(env, %W(soxi -t #{infile})).strip # ....
     fmt
   end
 

data/lib/dtas/mcache.rb

@@ -0,0 +1,31 @@
+# Copyright (C) 2016 all contributors <dtas-all@nongnu.org>
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
+# frozen_string_literal: true
+# encoding: binary
+require_relative '../dtas'
+
+class DTAS::Mcache
+  def initialize(shift = 8, ttl = 60)
+    @mask = (1 << shift) - 1
+    @ttl = ttl
+    @tbl = []
+  end
+
+  def lookup(infile)
+    bucket = infile.hash & @mask
+    if cur = @tbl[bucket]
+      if cur[:infile] == infile && (DTAS.now - cur[:btime]) < @ttl
+        return cur
+      end
+    end
+    return unless block_given?
+    @tbl[bucket] = begin
+      cur = cur ? cur.clear : {}
+      if ret = yield(infile, cur)
+        ret[:infile] = infile.frozen? ? infile : infile.dup.freeze
+        ret[:btime] = DTAS.now
+      end
+      ret
+    end
+  end
+end

data/lib/dtas/mlib.rb

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 # Copyright (C) 2015-2016 all contributors <dtas-all@nongnu.org>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
 #
 require_relative '../dtas'
@@ -190,7 +190,9 @@ def load_tags
       tag_id = tag_map[x] and tag_map["#{x}number"] = tag_id
     end
     @tag_rmap = tag_map.invert.freeze
-    tag_map.merge!(Hash[*(tag_map.map { |k,v| [k.upcase.freeze, v] }.flatten!)])
+    tag_map.merge!(Hash[*(tag_map.map { |k,v|
+      [DTAS.dedupe_str(k.upcase), v]
+    }.flatten!)])
     @tag_map = tag_map.freeze
   end
 
@@ -298,8 +300,10 @@ def scan_dir(path, st, parent_id = nil)
       dir = dir_vivify(@pwd.split(%r{/+}n), st.ctime.to_i)
       dir_id = dir[:id]
 
-      @db[:nodes].where(parent_id: dir_id).each do |node|
-        File.exist?(node[:name]) or remove_entry(node)
+      @db.transaction do
+        @db[:nodes].where(parent_id: dir_id).each do |node|
+          File.exist?(node[:name]) or remove_entry(node)
+        end
       end
 
       Dir.foreach('.', encoding: Encoding::BINARY) do |x|
@@ -398,7 +402,7 @@ def path_of(node, cache)
     return '/' if base == '' # root_node
     parent_id = node[:parent_id]
     base += '/' unless node[:tlen] >= 0
-    ppath = cache[parent_id] and return "#{ppath}/#{base}"
+    ppath = cache[parent_id] and return DTAS.dedupe_str("#{ppath}/#{base}")
     parts = []
     begin
       node = @db[:nodes][id: node[:parent_id]]
@@ -406,9 +410,9 @@ def path_of(node, cache)
       parts.unshift node[:name]
     end while true
     parts.unshift('')
-    cache[parent_id] = parts.join('/')
+    cache[parent_id] = DTAS.dedupe_str(parts.join('/'))
     parts << base
-    parts.join('/').freeze
+    DTAS.dedupe_str(parts.join('/'))
   end
 
   def emit_recurse(node, cache, cb)

data/lib/dtas/mlib/migrations/0001_initial.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2015-2016 all contributors <dtas-all@nongnu.org>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 
 Sequel.migration do
   up do

data/lib/dtas/nonblock.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2015-2016 all contributors <dtas-all@nongnu.org>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 
 class DTAS::Nonblock < IO # :nodoc:
   if RUBY_VERSION.to_f <= 2.0

data/lib/dtas/parse_freq.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2015-2016 all contributors <dtas-all@nongnu.org>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
 require_relative '../dtas'
 module DTAS::ParseFreq # :nodoc:

data/lib/dtas/parse_time.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 # Copyright (C) 2013-2016 all contributors <dtas-all@nongnu.org>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
 require_relative '../dtas'
 

data/lib/dtas/partstats.rb

@@ -1,6 +1,6 @@
 # -*- encoding: binary -*-
 # Copyright (C) 2013-2016 all contributors <dtas-all@nongnu.org>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
 require_relative '../dtas'
 require_relative 'xs'
@@ -173,8 +173,7 @@ def parse_stats(stats, trim_part, buf)
       else
         next
       end
-      key = $1
-      key.freeze
+      key = DTAS.dedupe_str($1)
       key_idx = @key_idx[key]
       parts = line.split(/\s+/)
       nshift.times { parts.shift } # remove stuff we don't need

data/lib/dtas/pipe.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2013-2016 all contributors <dtas-all@nongnu.org>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
 begin
   require 'io/splice'

data/lib/dtas/player.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2013-2016 all contributors <dtas-all@nongnu.org>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
 require 'yaml'
 require 'shellwords'
@@ -168,6 +168,7 @@ def self.load(hash)
 
       if sinks = hash["sinks"]
         sinks.each do |sink_hsh|
+          sink_hsh['name'] = DTAS.dedupe_str(sink_hsh['name'])
           sink = DTAS::Sink.load(sink_hsh)
           sink.env = to_omap(sink.env)
           @sinks[sink.name] = sink

data/lib/dtas/player/client_handler.rb

@@ -1,8 +1,9 @@
 # Copyright (C) 2013-2016 all contributors <dtas-all@nongnu.org>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
 require_relative '../xs'
 require_relative '../parse_time'
+require_relative '../../dtas'
 
 # client protocol handling for -player
 module DTAS::Player::ClientHandler # :nodoc:
@@ -134,7 +135,7 @@ def dpc_sink(io, msg)
       # or variable names.
       sink.valid_name?(name) or return io.emit("ERR sink name invalid")
 
-      sink.name = name
+      sink.name = DTAS.dedupe_str(name)
       active_before = sink.active
       before = __sink_snapshot(sink)
 
@@ -143,7 +144,7 @@ def dpc_sink(io, msg)
         k, v = kv.split('=', 2)
         case k
         when %r{\Aenv\.([^=]+)\z}
-          sink.env[$1] = v
+          sink.env[DTAS.dedupe_str($1)] = v
         when %r{\Aenv#([^=]+)\z}
           v == nil or return io.emit("ERR unset env has no value")
           sink.env.delete($1)
@@ -186,6 +187,21 @@ def bytes_decoded(src = @current)
     bytes = bytes < 0 ? 0 : bytes # maybe negative in case of sink errors
   end
 
+  def __goto_offset_samples(offset)
+    if offset.sub!(/\A\+/, '')
+      __offset_to_samples(offset)
+    elsif offset.sub!(/\A-/, '')
+      __offset_to_samples(offset) * -1
+    else # ignore leading '=' for sox compat with 2nd "trim" arg
+      __offset_to_samples(offset)
+    end
+  end
+
+  def __offset_to_samples(offset)
+    offset.sub!(/s\z/, '') and return offset.to_i
+    @current.format.hhmmss_to_samples(offset)
+  end
+
   # returns seek offset as an Integer in sample count
   def __seek_offset_adj(dir, offset)
     if offset.sub!(/s\z/, '')
@@ -259,8 +275,7 @@ def dpc_rg(io, msg)
       when "fallback_track"
         rv = set_bool(io, kv, v) { |b| @rg.fallback_track = b }
         rv == true or return rv
-      when %r{(?:gain_threshold|norm_threshold|
-              preamp|norm_level|fallback_gain|volume)[+-]?\z}x
+      when %r{(?:preamp|norm_level|fallback_gain|volume)[+-]?\z}x
         rv = adjust_numeric(io, @rg, k, v)
         rv == true or return rv
       end
@@ -377,7 +392,7 @@ def seek_internal(cur, offset)
   end
 
   def dpc_seek(io, msg)
-    offset = msg[0]
+    offset = msg[0] or return io.emit('ERR usage: seek OFFSET')
     if @current
       if @current.respond_to?(:infile)
         begin
@@ -730,6 +745,7 @@ def _dpc_tl_swap(io, msg)
   end
 
   def __bp_prev_next(io, msg, cur, bp)
+    # msg = [ (prev|next) [, (track|pregap|subindex|<digit>|any) ]
     case type = msg[1]
     when nil, "track"
       bp.keep_if(&:track?)
@@ -745,9 +761,9 @@ def __bp_prev_next(io, msg, cur, bp)
       return io.emit("INVALID TYPE")
     end
     fmt = cur.format
+    ds = __current_decoded_samples
     case msg[0]
     when "next"
-      ds = __current_decoded_samples
       bp.each do |ci|
         next if ci.offset_samples(fmt) < ds
         seek_internal(cur, ci.offset)
@@ -756,11 +772,15 @@ def __bp_prev_next(io, msg, cur, bp)
       # go to the next (real) track if not found
       __current_drop
     when "prev"
-      os = cur.offset_samples # where we currently started
+      prev = nil
       bp.reverse_each do |ci|
-        next if ci.offset_samples(fmt) >= os
-        seek_internal(cur, ci.offset)
-        return io.emit("OK")
+        if prev.nil?
+          next if ci.offset_samples(fmt) >= ds
+          prev = ci
+        else
+          seek_internal(cur, ci.offset)
+          return io.emit("OK")
+        end
       end
       # offset may be nil/zero if we couldn't find a previous breakpoint
       seek_internal(cur, '0')
@@ -768,6 +788,47 @@ def __bp_prev_next(io, msg, cur, bp)
     io.emit("OK")
   end
 
+  def __bp_seek(io, msg, cur, bp)
+    offset = msg[1] or return io.emit('ERR usage: cue seek OFFSET')
+
+    # relative + offset work just like normal, non-CUE "seek"
+    offset =~ /\A[\+-]/ and return dpc_seek(io, [ offset ])
+
+    # "=-" is special, it means go before the current index start:
+    dir = offset.sub!(/\A=-/, '') ? -1 : 1
+
+    begin
+      offset = __offset_to_samples(offset)
+    rescue ArgumentError
+      return io.emit('ERR bad time format')
+    end
+
+    ds = __current_decoded_samples
+    fmt = cur.format
+    prev = 0
+    bp.each do |ci|
+      ci_offset = ci.offset_samples(fmt)
+      break if ci_offset >= ds
+      prev = ci_offset
+    end
+    offset = offset * dir + prev
+    seek_internal(cur, "#{offset < 0 ? 0 : offset}s")
+    io.emit('OK')
+  end
+
+  def __bp_goto(io, msg, cur, bp)
+    index = msg[1] or return io.emit('NOINDEX')
+    ci = bp[index.to_i] or return io.emit('BADINDEX')
+    if offset = msg[2]
+      fmt = cur.format
+      offset = "#{ci.offset_samples(fmt) + __goto_offset_samples(offset)}s"
+    else
+      offset = ci.offset
+    end
+    seek_internal(cur, offset)
+    io.emit('OK')
+  end
+
   def dpc_cue(io, msg)
     cur = @current
     if cur.respond_to?(:cuebreakpoints)
@@ -778,11 +839,8 @@ def dpc_cue(io, msg)
         io.emit(tmp.to_yaml)
       when "next", "prev"
         return __bp_prev_next(io, msg, cur, bp)
-      when "goto"
-        index = msg[1] or return io.emit("NOINDEX")
-        ci = bp[index.to_i] or return io.emit("BADINDEX")
-        seek_internal(cur, ci.offset)
-        return io.emit("OK")
+      when 'seek' then return __bp_seek(io, msg, cur, bp)
+      when 'goto' then return __bp_goto(io, msg, cur, bp)
       end
     else
       io.emit("NOCUE")

data/lib/dtas/process.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2013-2016 all contributors <dtas-all@nongnu.org>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
 require 'io/wait'
 require 'shellwords'

data/lib/dtas/replaygain.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2013-2016 all contributors <dtas-all@nongnu.org>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
 
 # Represents ReplayGain metadata for a DTAS::Source, only used by -player

data/lib/dtas/rg_state.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2013-2016 all contributors <dtas-all@nongnu.org>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
 #
 # provides support for generating appropriate effects for ReplayGain
@@ -22,8 +22,6 @@ class DTAS::RGState # :nodoc:
   RG_DEFAULT = {
     "volume" => 1.0,
     # skip the effect if the adjustment is too small to be noticeable
-    "gain_threshold" => 0.00000001, # in dB
-    "norm_threshold" => 0.00000001,
 
     "preamp" => 0, # no extra adjustment
     # "mode" => "album_gain", # nil: off
@@ -73,23 +71,21 @@ def to_sox_gain(val)
     when -1 then return 'gain -192'
     when 1 then return 'gain 192'
     else
-      sprintf('gain %0.8g', val).freeze
+      val.abs <= 0.00000001 and return
+      DTAS.dedupe_str(sprintf('gain %0.8f', val))
     end
   end
 
   # returns a dB argument to the "gain" effect, nil if nothing found
   def rg_vol_gain(val)
     val = val.to_f + @preamp + vol_db
-    return if val.abs < @gain_threshold
     to_sox_gain(val)
   end
 
   # returns a DB argument to the "gain" effect
   def rg_vol_norm(val)
     n = @norm_level == 1.0 ? @volume : @norm_level
-    diff = n - val.to_f
-    return if (n - diff).abs < @norm_threshold
-    diff += n
+    diff = n * 2 - val.to_f
     to_sox_gain(linear_to_db(diff))
   end
 
@@ -99,7 +95,6 @@ def rg_vol_norm(val)
   # tag slips into the queue
   def rg_fallback_effect(reason)
     val = (@fallback_gain || 0) + @preamp + vol_db
-    return if val.abs < @gain_threshold
     warn(reason) if $DEBUG
     to_sox_gain(val)
   end

data/lib/dtas/serialize.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2013-2016 all contributors <dtas-all@nongnu.org>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
 
 # used to serialize player state to the state file

data/lib/dtas/sigevent.rb

@@ -1,5 +1,5 @@
 # Copyright (C) 2013-2016 all contributors <dtas-all@nongnu.org>
-# License: GPL-3.0+ (https://www.gnu.org/licenses/gpl-3.0.txt)
+# License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
 # frozen_string_literal: true
 begin
   raise LoadError, "no eventfd with _DTAS_POSIX" if ENV["_DTAS_POSIX"]