dtas 0.3.0 → 0.4.0

data/lib/dtas/sink.rb

@@ -7,7 +7,6 @@ require_relative 'process'
 require_relative 'command'
 require_relative 'format'
 require_relative 'serialize'
-require_relative 'writable_iter'
 
 # this is a sink (endpoint, audio enters but never leaves)
 class DTAS::Sink # :nodoc:
@@ -20,7 +19,6 @@ class DTAS::Sink # :nodoc:
   include DTAS::Command
   include DTAS::Process
   include DTAS::Serialize
-  include DTAS::WritableIter
 
   SINK_DEFAULTS = COMMAND_DEFAULTS.merge({
     "name" => nil, # order matters, this is first
@@ -39,7 +37,6 @@ class DTAS::Sink # :nodoc:
 
   def initialize
     command_init(SINK_DEFAULTS)
-    writable_iter_init
     @sink = self
   end
 

data/lib/dtas/source/sox.rb

@@ -11,6 +11,7 @@ class DTAS::Source::Sox # :nodoc:
 
   include DTAS::Source::File
   include DTAS::XS
+  extend DTAS::XS
 
   SOX_DEFAULTS = COMMAND_DEFAULTS.merge(
     "command" => 'exec sox "$INFILE" $SOXFMT - $TRIMFX $RGFX',
@@ -40,7 +41,7 @@ class DTAS::Source::Sox # :nodoc:
   def try(infile, offset = nil)
     err = ""
     cmd = %W(soxi -s #{infile})
-    s = qx(@env, cmd, err_str: err, no_raise: true)
+    s = qx(@env.dup, 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)

data/lib/dtas/splitfx.rb

@@ -0,0 +1,342 @@
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net> and all contributors
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+# Unlike the stuff for dtas-player, dtas-splitfx is fairly tied to sox
+# (but we may still pipe to ecasound or anything else)
+require_relative '../dtas'
+require_relative 'format'
+require_relative 'process'
+require_relative 'xs'
+require 'tempfile'
+class DTAS::SplitFX # :nodoc:
+  CMD = 'sox "$INFILE" $COMMENTS $OUTFMT "$TRACKNUMBER.$SUFFIX" '\
+        '$TRIMFX $RATEFX $DITHERFX'
+  include DTAS::Process
+  include DTAS::XS
+
+  class Skip < Struct.new(:tstart) # :nodoc:
+    def commit(_)
+      # noop
+    end
+  end
+
+  class T < Struct.new(:env, :comments, :tstart, :fade_in, :fade_out) # :nodoc:
+    def commit(advance_track_samples)
+      tlen = advance_track_samples - tstart
+      trimfx = "trim #{tstart}s #{tlen}s"
+      if fade_in
+        trimfx << " #{fade_in}"
+      end
+      if fade_out
+        tmp = fade_out.dup
+        fade_out_len = tmp.pop or
+                         raise ArgumentError, "fade_out needs a time value"
+        fade_type = tmp.pop # may be nil
+        fade = " fade #{fade_type} 0 #{tlen}s #{fade_out_len}"
+        trimfx << fade
+      end
+      env["TRIMFX"] = trimfx
+    end
+  end
+
+  # vars:
+  # $CHANNELS (input)
+  # $BITS_PER_SAMPLE (input)
+  def initialize
+    @env = {}
+    @comments = {}
+    @track_start = 1
+    @track_zpad = true
+    @t2s = method(:t2s)
+    @infile = nil
+    @targets = {
+      "flac-cdda" => {
+        "command" => CMD,
+        "format" => {
+          "bits" => 16,
+          "rate" => 44100,
+          "type" => "flac",
+          "channels" => 2,
+        },
+      },
+      "opusenc" => {
+        "command" => 'sox "$INFILE" $COMMENTS $OUTFMT - ' \
+           '$TRIMFX $RATEFX $DITHERFX | opusenc --music ' \
+           '--raw-bits $BITS_PER_SAMPLE ' \
+           '$OPUSENC_BITRATE --raw-rate $RATE --raw-chan $CHANNELS ' \
+           '--raw-endianness $ENDIAN_OPUSENC ' \
+           '$OPUSENC_COMMENTS ' \
+           '- $TRACKNUMBER.opus',
+        "format" => {
+          "bits" => 16,
+          "rate" => 48000,
+          "type" => "s16",
+          "channels" => 2,
+        },
+      },
+    }
+    @tracks = []
+    @infmt = nil # wait until input is assigned
+  end
+
+  def _bool(hash, key)
+    val = hash[key]
+    case val
+    when false, true then yield val
+    when nil # ignore
+    else
+      raise TypeError, "'#{key}' must be boolean (true or false)"
+    end
+  end
+
+  def import(hash, overrides = {})
+    # merge overrides from the command-line
+    overrides.each do |k,v|
+      case v
+      when Hash then hash[k] = (hash[k] || {}).merge(v)
+      else
+        hash[k] = v
+      end
+    end
+
+    hash = hash.merge(overrides)
+    case v = hash["track_zpad"]
+    when Integer then @track_zpad = val
+    else
+      _bool(hash, "track_zpad") { |val| @track_zpad = val }
+    end
+
+    _bool(hash, "cdda_align") { |val| @t2s = method(val ? :t2s : :t2s_cdda) }
+
+    case v = hash["track_start"]
+    when Integer then @track_start = v
+    when nil
+    else
+      raise TypeError, "'track_start' must be an integer"
+    end
+
+    %w(comments env targets).each do |key|
+      case val = hash[key]
+      when Hash then instance_variable_get("@#{key}").merge!(val)
+      when nil
+      else
+        raise TypeError, "'#{key}' must be a hash"
+      end
+    end
+
+    @targets.each_value do |thsh|
+      case tfmt = thsh["format"]
+      when Hash
+        thsh["format"] = DTAS::Format.load(tfmt) unless tfmt.empty?
+      end
+    end
+
+    load_input!(hash)
+    load_tracks!(hash)
+  end
+
+  # FIXME: duplicate from dtas/source/sox
+  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/n
+    v = $1.to_i
+    return v if v > 0
+    raise TypeError, "could not determine precision for #@infile"
+  end
+
+  def load_input!(hash)
+    @infile = hash["infile"] or raise ArgumentError, "'infile' not specified"
+    if infmt = hash["infmt"] # rarely needed
+      @infmt = DTAS::Format.load(infmt)
+    else # likely
+      @infmt = DTAS::Format.new
+      @infmt.channels = qx(@env, %W(soxi -c #@infile)).to_i
+      @infmt.rate = qx(@env, %W(soxi -r #@infile)).to_i
+      @infmt.bits ||= precision
+      # we don't care for type
+    end
+  end
+
+  def generic_target(target = "flac")
+    outfmt = @infmt.dup
+    outfmt.type = target
+    { "command" => CMD, "format" => outfmt }
+  end
+
+  def spawn(target, t, opts)
+    target = @targets[target] || generic_target(target)
+    outfmt = target["format"]
+    env = outfmt.to_env
+
+    # set very high quality resampling if using 24-bit or higher output
+    if outfmt.rate != @infmt.rate
+      if outfmt.bits
+        # set very-high resampling quality for 24-bit outputs
+        quality = "-v" if outfmt.bits >= 24
+      else
+        # assume output bits matches input bits
+        quality = "-v" if @infmt.bits >= 24
+      end
+      env["RATEFX"] = "rate #{quality} #{outfmt.rate}"
+    end
+
+    # add noise-shaped dither for 16-bit (sox manual seems to recommend this)
+    outfmt.bits && outfmt.bits <= 16 and env["DITHERFX"] = "dither -s"
+    comments = Tempfile.new(%W(dtas-splitfx-#{t.comments["TRACKNUMBER"]} .txt))
+    comments.sync = true
+    t.comments.each do |k,v|
+      env[k] = v.to_s
+      comments.puts("#{k}=#{v}")
+    end
+    env["COMMENTS"] = "--comment-file=#{comments.path}"
+    env["INFILE"] = @infile
+    env["OUTFMT"] = xs(outfmt.to_sox_arg)
+    env["SUFFIX"] = outfmt.type
+    env.merge!(t.env)
+
+    command = target["command"]
+    tmp = Shellwords.split(command).map do |arg|
+      qx(env, "printf %s \"#{arg}\"")
+    end
+    echo = "echo #{xs(tmp)}"
+    if opts[:dryrun]
+      command = echo
+    else
+      system(echo) unless opts[:silent]
+    end
+
+    # pgroup: false so Ctrl-C on command-line will immediately stop everything
+    [ dtas_spawn(env, command, pgroup: false), comments ]
+  end
+
+  def load_tracks!(hash)
+    tracks = hash["tracks"] or raise ArgumentError, "'tracks' not specified"
+    tracks.each { |line| parse_track(Shellwords.split(line)) }
+
+    fmt = "%d"
+    case @track_zpad
+    when true
+      max = @track_start - 1 + @tracks.size
+      fmt = "%0#{max.to_s.size}d"
+    when Integer
+      fmt = "%0#{@track_zpad}d"
+    else
+      fmt = "%d"
+    end
+    nr = @track_start
+    @tracks.delete_if do |t|
+      case t
+      when Skip
+        true
+      else
+        t.comments["TRACKNUMBER"] = sprintf(fmt, nr)
+        nr += 1
+        false
+      end
+    end
+  end
+
+  # argv:
+  #   [ 't', '0:05', 'track one', 'fade_in=t 4', '.comment=blah' ]
+  #   [ 'stop', '1:00' ]
+  def parse_track(argv)
+    case cmd = argv.shift
+    when "t"
+      start_time = argv.shift
+      title = argv.shift
+      t = T.new
+      t.tstart = @t2s.call(start_time)
+      t.comments = @comments.dup
+      t.comments["TITLE"] = title
+      t.env = @env.dup
+
+      argv.each do |arg|
+        case arg
+        when %r{\Afade_in=(.+)\z}
+          # generate fade-in effect
+          # $1 = "t 4" => "fade t 4 0 0"
+          t.fade_in = "fade #$1 0 0"
+        when %r{\Afade_out=(.+)\z} # $1 = "t 4" or just "4"
+          t.fade_out = $1.split(/\s+/)
+        when %r{\A\.(\w+)=(.+)\z} then t.comments[$1] = $2
+        else
+          raise ArgumentError, "unrecognized arg(s): #{xs(argv)}"
+        end
+      end
+
+      prev = @tracks.last and prev.commit(t.tstart)
+      @tracks << t
+    when "skip"
+      stop_time = argv.shift
+      argv.empty? or raise ArgumentError, "skip does not take extra args"
+      s = Skip.new
+      s.tstart = @t2s.call(stop_time)
+      # s.comments = {}
+      # s.env = {}
+      prev = @tracks.last or raise ArgumentError, "no tracks to skip"
+      prev.commit(s.tstart)
+      @tracks << s
+    when "stop"
+      stop_time = argv.shift
+      argv.empty? or raise ArgumentError, "stop does not take extra args"
+      samples = @t2s.call(stop_time)
+      prev = @tracks.last and prev.commit(samples)
+    else
+      raise ArgumentError, "unknown command: #{xs(Array(cmd))}"
+    end
+  end
+
+  # like t2s, but align to CDDA sectors (75 frames per second)
+  def t2s_cdda(time)
+    time = time.dup
+    frac = 0
+
+    # fractions of a second, convert to samples based on sample rate
+    # taking into account CDDA alignment
+    if time.sub!(/\.(\d+)\z/, "")
+      s = "0.#$1".to_f * @infmt.rate / 75
+      frac = s.round * 75
+    end
+
+    # feed the rest to the normal function
+    t2s(time) + frac
+  end
+
+  def t2s(time)
+    @infmt.hhmmss_to_samples(time)
+  end
+
+  def run(target, opts = {})
+    fails = []
+    tracks = @tracks.dup
+    pids = {}
+    jobs = opts[:jobs] || tracks.size # jobs == nil => everything at once
+    jobs.times.each do
+      t = tracks.shift or break
+      pid, tmp = spawn(target, t, opts)
+      pids[pid] = [ t, tmp ]
+    end
+
+    while pids.size > 0
+      pid, status = Process.waitpid2(-1)
+      done = pids.delete(pid)
+      if status.success?
+        if t = tracks.shift
+          pid, tmp = spawn(target, t, opts)
+          pids[pid] = [ t, tmp ]
+        end
+        puts "DONE #{done[0].inspect}" if $DEBUG
+        done[1].close!
+      else
+        fails << [ t, status ]
+      end
+    end
+
+    return true if fails.empty? && tracks.empty?
+    fails.each do |(_t,s)|
+      warn "FAIL #{s.inspect} #{_t.inspect}"
+    end
+    false
+  end
+end

data/lib/dtas/tracklist.rb

@@ -0,0 +1,130 @@
+# Copyright (C) 2013, Eric Wong <normalperson@yhbt.net> and all contributors
+# License: GPLv3 or later (https://www.gnu.org/licenses/gpl-3.0.txt)
+require_relative '../dtas'
+require_relative 'serialize'
+
+# this is inspired by the MPRIS 2.0 TrackList spec
+class DTAS::Tracklist # :nodoc:
+  include DTAS::Serialize
+  attr_accessor :repeat # true, false, 1
+
+  SIVS = %w(list pos repeat)
+  TL_DEFAULTS = {
+    "list" => [],
+    "pos" => -1,
+    "repeat" => false,
+  }
+
+  def self.load(hash)
+    obj = new
+    obj.instance_eval do
+      list = hash["list"] and @list.replace(list)
+      @pos = hash["pos"] || -1
+      @repeat = hash["repeat"] || false
+    end
+    obj
+  end
+
+  def to_hsh
+    ivars_to_hash(SIVS).delete_if { |k,v| TL_DEFAULTS[k] == v }
+  end
+
+  def initialize
+    TL_DEFAULTS.each { |k,v| instance_variable_set("@#{k}", v) }
+    @list = []
+    @goto_off = @goto_pos = nil
+  end
+
+  def reset
+    @goto_off = @goto_pos = nil
+    @pos = TL_DEFAULTS["pos"]
+  end
+
+  def size
+    @list.size
+  end
+
+  # caching this probably isn't worth it.  a tracklist is usually
+  # a few tens of tracks, maybe a hundred at most.
+  def _track_id_map
+    by_track_id = {}
+    @list.each_with_index { |t,i| by_track_id[t.object_id] = i }
+    by_track_id
+  end
+
+  def get_tracks(track_ids)
+    by_track_id = _track_id_map
+    track_ids.map do |track_id|
+      idx = by_track_id[track_id]
+      # dtas-mpris fills in the metadata, we just return a path
+      [ track_id, idx ? @list[idx] : nil ]
+    end
+  end
+
+  def tracks
+    @list.map { |t| t.object_id }
+  end
+
+  def advance_track(repeat_ok = true)
+    return if @list.empty?
+    # @repeat == 1 for single track repeat
+    next_pos = @goto_pos || @pos + (@repeat == 1 ? 0 : 1)
+    next_off = @goto_off # nil by default
+    @goto_pos = @goto_off = nil
+    if @list[next_pos]
+      @pos = next_pos
+    elsif @repeat && repeat_ok
+      next_pos = @pos = 0
+    else
+      return
+    end
+    [ @list[next_pos], next_off ]
+  end
+
+  def cur_track
+    @pos >= 0 ? @list[@pos] : nil
+  end
+
+  def add_track(track, after_track_id = nil, set_as_current = false)
+    if after_track_id
+      by_track_id = _track_id_map
+      idx = by_track_id[after_track_id] or
+        raise ArgumentError, "after_track_id invalid"
+      @list[idx, 1] = [ @list[idx], track ]
+      @pos = idx + 1 if set_as_current
+    else # nil = first_track
+      @list.unshift(track)
+      @pos = 0 if set_as_current
+    end
+    track.object_id
+  end
+
+  def remove_track(track_id)
+    by_track_id = _track_id_map
+    if idx = by_track_id.delete(track_id)
+      @list[idx] = nil
+      @list.compact!
+      # TODO: what do we do with @pos (and the currently-playing track)
+    end
+  end
+
+  def go_to(track_id, offset_hhmmss = nil)
+    by_track_id = _track_id_map
+    if idx = by_track_id[track_id]
+      @goto_off = offset_hhmmss
+      return @list[@goto_pos = idx]
+    end
+    @goto_pos = nil
+    # noop if track_id is invalid
+  end
+
+  def previous!
+    return if @list.empty?
+    prev_idx = @pos - 1
+    if prev_idx < 0
+      # stop playback if nothing to go back to.
+      prev_idx = @repeat ? @list.size - 1 : @list.size
+    end
+    @goto_pos = prev_idx
+  end
+end