ruck 0.1.0

data/examples/ugen/ex02.rb

@@ -0,0 +1,2 @@
+SinOsc.new(:freq => 440) >> WavOut.new(:filename => "ex02.wav") >> blackhole
+play 3.seconds

data/examples/ugen/ex03.rb

@@ -0,0 +1,8 @@
+wav = WavOut.new(:filename => "ex03.wav")
+sin2 = SinOsc.new(:freq => 3)
+sin = SinOsc.new(:freq => L{ sin2.last * 220 + 660 },
+                 :gain => L{ 0.5 + sin2.last * 0.5 })
+
+[sin >> wav, sin2] >> blackhole
+
+play 3.seconds

data/examples/ugen/ex04.rb

@@ -0,0 +1,14 @@
+(wav = WavOut.new(:filename => "ex04.wav")) >> blackhole
+s = SawOsc.new(:freq => 440, :gain => 0.5)
+adsr = ADSR.new(:attack_time => 50.ms,
+                :attack_gain => 1.0,
+                :decay_time => 50.ms,
+                :sustain_gain => 0.5,
+                :release_time => 1.second)
+s >> adsr >> wav
+
+play 1.second
+adsr.on
+play 2.seconds
+adsr.off
+play 2.seconds

data/examples/ugen/ex05.rb

@@ -0,0 +1,9 @@
+wav = WavIn.new(:filename => "ex01.wav")
+wav >> WavOut.new(:filename => "ex05.wav") >> blackhole
+
+wav.play
+play 1.second
+
+(r = Ramp.new(:from => 1.0, :to => 2.0, :duration => 3.seconds)) >> blackhole
+wav.rate = L{ r.last }
+play 3.seconds

data/examples/ugen/ex06.rb

@@ -0,0 +1,10 @@
+# run ex01.rb first
+
+spoken = WavIn.new(:filename => "ex01.wav")
+wav = WavOut.new(:filename => "ex06.wav")
+spoken.out(0) >> wav >> blackhole
+
+(sin = SinOsc.new(:freq => 3, :gain => 0.1)) >> blackhole
+spoken.rate = L{ 1.0 + sin.last }
+
+play spoken.duration

data/examples/ugen/ex07.rb

@@ -0,0 +1,35 @@
+@bpm = 130.0
+@one_beat = (1.0 / @bpm).minutes
+
+(@wav = WavOut.new(:filename => "ex07.wav")) >> blackhole
+
+def smash(len = @one_beat)
+  (n = Noise.new(:gain => 0.4)) >> (a = ADSR.new) >> @wav
+  a.release_time = len
+  a.on; play @one_beat / 1.5
+  a.off; play len
+  a << @wav
+end
+
+def beat
+  (thump = SawOsc.new(:freq => 220, :gain => 0.7)) >> (a = ADSR.new) >> @wav
+  a.on; play @one_beat / 2.0
+  a.off; play a.release_time
+  a << @wav
+end
+
+4.times do
+  spork("beat 1") { beat }; spork("smash") { smash }
+  play @one_beat
+
+  spork("beat 2") { beat }
+  play @one_beat
+
+  spork("beat 3") { beat }
+  play @one_beat
+
+  spork("beat 4") { beat }
+  play @one_beat
+end
+
+smash(5.seconds)

data/examples/ugen/ex08.rb

@@ -0,0 +1,28 @@
+# An experiment with formants
+# http://en.wikipedia.org/wiki/Formant
+
+wav = WavOut.new(:filename => "ex08.wav")
+ramps = (1..4).map { Ramp.new(:duration => 50.ms) }
+oscillators = (1..4).map { SinOsc.new }
+[oscillators >> wav, ramps] >> blackhole
+
+(0..3).each { |i| oscillators[i].freq = L{ ramps[i].last } }
+
+#vowel_ah = [1000, 1400]
+#vowel_eh = [500, 2300]
+#vowel_oh = [500, 1000]
+vowel_ee = [[320, 1.0], [2500, 1.0], [3200, 1.0], [4600, 0.6]]
+vowel_oo = [[320, 1.0], [800, 0.3], [2500, 0.1], [3300, 0.1]]
+
+5.times do
+  [vowel_ee, vowel_oo].each do |vowel|
+    puts "doing #{vowel.inspect}"
+    (0..3).each do |i|
+      ramps[i].reset
+      ramps[i].from = ramps[i].to
+      ramps[i].to = vowel[i].first
+      oscillators[i].gain = vowel[i].last / 4.0
+    end
+    play 1.second
+  end
+end

data/examples/ugen/ex09.rb

@@ -0,0 +1,26 @@
+# run ex01.rb first (or, preferably, use way better input than ex01.wav)
+
+=begin
+https://lists.cs.princeton.edu/pipermail/chuck-users/2008-May/002983.html
+
+> One way of subjectively "widening" a stereo image is to do the following:
+> feed the left channel back to the right with a short delay, inverted;
+> feed the right channel back to the left with a short delay, inverted;
+=end
+
+mix = 0.5
+
+wavin = WavIn.new :filename => "ex01.wav", :gain => (1.0 - mix)
+wavout = WavOut.new :filename => "ex09.wav", :num_channels => 2
+
+wavin.out(0) >> (delayed_left =  Delay.new :time => 10.ms, :gain => mix)
+wavin.out(1) >> (delayed_right = Delay.new :time => 10.ms, :gain => mix)
+inverted_left = Step.new :value => L{ -delayed_left.next(now) }
+inverted_right = Step.new :value => L{ -delayed_right.next(now) }
+
+wavout >> blackhole
+[wavin.out(0), inverted_right] >> wavout.in(0)
+[wavin.out(1), inverted_left ] >> wavout.in(1)
+
+play wavin.duration
+puts "processed #{wavin.duration/SAMPLE_RATE} seconds"

data/examples/ugen/ex10.rb

@@ -0,0 +1,15 @@
+# when run with RealTimeShreduler, illustrates the passage of time
+
+spork("a") do
+  loop do
+    play 1.second
+    puts "second"
+  end
+end
+
+spork("b") do
+  loop do
+    play 0.5.second
+    puts "       half-second"
+  end
+end

data/examples/ugen/ex11.rb

@@ -0,0 +1,10 @@
+# multi-channel WavOut
+
+s1 = SinOsc.new :freq => 440
+s2 = SinOsc.new :freq => 440 * 2
+wav = WavOut.new :filename => "ex11.wav", :num_channels => 2
+s1 >> wav.in(0)
+s2 >> wav.in(1)
+wav >> blackhole
+
+play 3.seconds

data/examples/ugen/ex12.rb

@@ -0,0 +1,9 @@
+# adds 60 Hz hum to a stereo wav file
+
+wavin = WavIn.new :filename => "ex11.wav", :gain => 0.5
+wavout = WavOut.new :filename => "ex12.wav", :num_channels => 2
+wavin >> wavout
+SinOsc.new(:freq => 60, :gain => 0.5) >> wavout
+wavout >> blackhole
+
+play 3.seconds

data/lib/ruck.rb

@@ -0,0 +1,13 @@
+
+module Ruck
+  require "logger"
+  LOG = Logger.new(STDOUT)
+  LOG.level = Logger::WARN
+end
+
+require File.join(File.dirname(__FILE__), "ruck", "shreduling")
+require File.join(File.dirname(__FILE__), "ruck", "misc", "metaid")
+require File.join(File.dirname(__FILE__), "ruck", "misc", "linkage")
+require File.join(File.dirname(__FILE__), "ruck", "ugen", "general")
+require File.join(File.dirname(__FILE__), "ruck", "ugen", "wav")
+require File.join(File.dirname(__FILE__), "ruck", "ugen", "oscillators")

data/lib/ruck/bench.rb

@@ -0,0 +1,44 @@
+
+SAMPLE_RATE = 44100
+
+if ARGV.include? "bench.rb"
+  # benchmark UGens with shreduling
+
+  TIME = 1.seconds
+  count = 0
+  puts "Simulating #{TIME / 1.second} seconds"
+  loop do
+    Step.new >> blackhole
+    count += 1
+
+    start = Time.now
+    play TIME
+    time = Time.now - start
+    puts "#{count}: #{time}"
+
+    break if time > (TIME / 1.second)
+  end
+else
+  # benchmark UGens without shreduling
+
+  require "ruck"
+  TIME = 1.seconds
+  dac = Ruck::InChannel.new
+  count = 0
+  @now = 0
+  puts "Simulating #{TIME / 1.second} seconds"
+  loop do
+    Ruck::Generators::Step.new >> dac
+    count += 1
+
+    start = Time.now
+    TIME.to_i.times do
+      dac.next(@now)
+      @now += 1
+    end
+    time = Time.now - start
+    puts "#{count}: #{time}"
+
+    break if time > (TIME / 1.second)
+  end
+end

data/lib/ruck/misc/linkage.rb

@@ -0,0 +1,22 @@
+
+class Object
+  def linkable_attr(attr_sym)
+    attr_reader attr_sym
+    define_method("#{attr_sym}=") do |val|
+      instance_variable_set("@#{attr_sym}", val)
+      if val.respond_to? :call
+        meta_def attr_sym do
+          val.call
+        end
+      else
+        meta_def attr_sym do
+          val
+        end
+      end
+    end
+  end
+
+  def L(&block)
+    block
+  end
+end

data/lib/ruck/misc/metaid.rb

@@ -0,0 +1,18 @@
+# stolen from:
+# http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+
+class Object
+  # The hidden singleton lurks behind everyone
+  def metaclass; class << self; self; end; end
+  def meta_eval &blk; metaclass.instance_eval &blk; end
+
+  # Adds methods to a metaclass
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+
+  # Defines an instance method within a class
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+end

data/lib/ruck/misc/pcm_time_helpers.rb

@@ -0,0 +1,29 @@
+
+module RuckTime
+  def sample
+    self
+  end
+  alias_method :samples, :sample
+  
+  def ms
+    self.to_f * SAMPLE_RATE / 1000.0
+  end
+  
+  def second
+    self.to_f * SAMPLE_RATE
+  end
+  alias_method :seconds, :second
+  
+  def minute
+    self.to_f * SAMPLE_RATE * 60.0
+  end
+  alias_method :minutes, :minute
+end
+
+class Fixnum
+  include RuckTime
+end
+
+class Float
+  include RuckTime
+end

data/lib/ruck/misc/riff.rb

@@ -0,0 +1,71 @@
+
+module Riff
+  
+  class RiffReaderChunk
+    attr_reader :data_start
+    attr_accessor :data_skip
+    
+    def initialize(fn, start)
+      @fn, @start = fn, start
+      @size_start = @start + 4
+      @data_start = @start + 8
+      @data_skip = 0
+    end
+    
+    def type
+      return @type if @type
+      @fn.seek @start
+      @type = @fn.read(4)
+    end
+    
+    def size
+      return @size - @data_skip if @size
+      @fn.seek @size_start
+      @size = @fn.read(4).unpack("L")[0]
+      @size - @data_skip
+    end
+    
+    # pass a Range of bytes, or start and length
+    def [](*args)
+      first, last = case args.length
+                    when 1; [args.first.begin, args.first.end]
+                    when 2; [args[0], args[0] + args[1]]
+                    end
+      @fn.seek @data_start + @data_skip + first
+      @fn.read(last - first + 1)
+    end
+    
+    def chunks
+      offset = @data_start + @data_skip
+      chunks = []
+      while offset + @data_skip - @data_start < size
+        chunks << chunk = RiffReaderChunk.new(@fn, offset)
+        offset += @data_start + chunk.size
+      end
+      chunks
+    end
+    
+    def to_s
+      "<RiffHeader type:#{type} size:#{size}>"
+    end
+    
+  end
+
+  class RiffReader
+    def initialize(filename)
+      @fn = File.open(filename, "rb")
+    end
+    
+    def chunks
+      offset = 0
+      chunks = []
+      until @fn.eof?
+        chunks << chunk = RiffReaderChunk.new(@fn, offset)
+        offset += 8 + chunk.size
+        @fn.seek offset + 8
+      end
+      chunks
+    end
+  end
+  
+end

data/lib/ruck/misc/wavparse.rb

@@ -0,0 +1,35 @@
+# stolen from
+# http://www.mokehehe.com/assari/index.php?WAV%A5%D5%A5%A1%A5%A4%A5%EB%C6%E2%A4%CE%A5%C1%A5%E3%A5%F3%A5%AF%A4%F2%CE%F3%B5%F3%A4%B9%A4%EB
+
+if ARGV.length < 1
+    print "usage: [input wav filename]\n"
+    exit
+end
+ 
+inwavfn = ARGV[0]
+
+File::open(inwavfn, "rb") {|f|
+    riff = f.read(4)
+    if riff != 'RIFF'
+        STDERR.print "not RIFF\n"
+        exit
+    end
+    totalsizestr = f.read(4)
+    totalsize = totalsizestr.unpack("L")[0]
+ 
+    wave = f.read(4)
+    if wave != 'WAVE'
+        STDERR.print "not WAVE\n"
+        exit
+    end
+ 
+    while !f.eof
+        chk = f.read(4)
+        chksizestr = f.read(4)
+        chksize = chksizestr.unpack("L")[0]
+ 
+        print chk, ",#{chksize}\n"
+ 
+        f.seek(chksize, IO::SEEK_CUR)
+    end
+}

data/lib/ruck/shreduling.rb

@@ -0,0 +1,147 @@
+
+module Ruck
+
+  class Shred
+    attr_reader :now
+    attr_accessor :finished
+
+    def initialize(shreduler, now, name, &block)
+      @shreduler = shreduler
+      @now = now
+      @name = name
+      @block = block
+      @finished = false
+    end
+
+    def go(resume)
+      @resume = resume
+      begin
+        @block.call self
+      rescue => e
+        LOG.error "#{self} exited uncleanly:\n#{e}\n#{e.backtrace}"
+      end
+      @finished = true
+    end
+
+    def yield(samples)
+      LOG.debug "shred #{self} yielding #{samples}"
+      samples = samples
+      @now += samples
+      callcc do |cont|
+        @block = cont # save where we are
+        @resume.call # jump back to shreduler
+      end
+      samples
+    end
+
+    def finish
+      @resume.call # last save point
+    end
+
+    # shreds sort in order of position in time
+    def <=>(shred)
+      @now <=> shred.now
+    end
+
+    def to_s
+      "<Shred: #{@name}>"
+    end
+  end
+
+  class Shreduler
+    attr_reader :running
+    attr_reader :current_shred
+    attr_reader :shreds
+    attr_reader :now
+
+    def initialize
+      @shreds = []
+      @now = 0
+      @running = false
+    end
+
+    def spork(name = "", &shred)
+      LOG.debug "Adding shred \"#{name}\" at #{@now}"
+      @shreds << Shred.new(self, @now, name, &shred)
+      @shred
+    end
+
+    def remove_shred(shred)
+      LOG.debug "Removing shred \"#{name}\" at #{@now}"
+      @shreds.delete shred
+    end
+    
+    def next_shred
+      @shreds.min # furthest behind (Shred#<=> uses Shred's current time)
+    end
+
+    # called when shreds allow time to pass
+    # a convnient method to override
+    def sim_to(new_now)
+      @now = new_now
+    end
+    
+    # invokes the next shred, simulates to the new VM time, then returns
+    def run_one
+      @current_shred = next_shred
+      
+      sim_to(@current_shred.now)
+      
+      # execute shred, saving this as the resume point
+      LOG.debug "resuming shred #{@current_shred} at #{now}"
+      callcc { |cont| @current_shred.go(cont) }
+      LOG.debug "back to run loop"
+
+      if @current_shred.finished
+        LOG.debug "#{@current_shred} finished"
+        @shreds.delete(@current_shred)
+      end
+    end
+
+    # ruck main loop
+    # executes all shreds and synthesizes audio
+    #   until all shreds exit
+    def run
+      LOG.debug "shreduler starting"
+      @running = true
+
+      while @shreds.length > 0
+        run_one
+      end
+
+      @running = false
+    end
+  end
+  
+  class UGenShreduler < Shreduler
+    def run
+      require File.join(File.dirname(__FILE__), "misc", "pcm_time_helpers")
+      super
+    end
+    
+    def sim_to(new_now)
+      while @now < new_now.to_i
+        BLACKHOLE.next @now
+        @now += 1
+      end
+    end
+  end
+  
+  class RealTimeShreduler < Shreduler
+    def run
+      @start_time = Time.now
+      super
+    end
+    
+    def sim_to(new_now)
+      actual_now = Time.now
+      simulated_now = @start_time + (new_now.to_f / SAMPLE_RATE)
+      if simulated_now > actual_now
+        sleep(simulated_now - actual_now)
+      end
+      
+      @now = new_now
+    end
+  end
+
+end