ruck-ugen 0.2.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/README

@@ -0,0 +1,31 @@
+ruck-ugen's shreduler calculates an audio unit generator
+graph's output in virtual time. The graph can be modified by
+shreds all the while.
+
+The graph is written in Ruby for flexibility, so it's
+too slow (on my computer) for real time, so there is no
+real-time playback. You can use WavOut, though.
+(See examples/ex01.rb)
+
+Check out the library of built-in unit generators in
+lib/ruck/ugen/ugen/ and make your own.
+
+Unit Generator Usage
+====================
+
+Play a sine wave (examples/ex02.rb):
+
+  s = SinOsc.new(:freq => 440)
+  w = WavOut.new(:filename => "ex02.wav")
+  s >> w >> blackhole
+  play 3.seconds
+
+Attach lambdas to unit generator attributes
+(examples/ex03.rb):
+
+  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/Rakefile

@@ -0,0 +1,24 @@
+require "rubygems"
+require "rake"
+
+begin
+  require "jeweler"
+  Jeweler::Tasks.new do |gem|
+    gem.name = "ruck-ugen"
+    gem.email = "tom@alltom.com"
+    gem.homepage = "http://github.com/alltom/ruck-ugen"
+    gem.authors = ["Tom Lieber"]
+    gem.summary = %Q{ruck shreduler + mini audio unit generator framework inspired by ChucK}
+    gem.description = <<-EOF
+      A ruck shreduler and mini audio unit generator framework inspired by ChucK.
+      Includes library for reading and writing multi-channel WAV files, and some
+      basic audio filters.
+    EOF
+    gem.has_rdoc = false
+    gem.add_dependency "ruck", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/bin/ruck_ugen

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+
+# for testing inside gem dir
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require "ruck"
+require "ruck/ugen"
+
+SAMPLE_RATE = 22050
+SHREDULER = Ruck::UGen::UGenShreduler.new
+BLACKHOLE = Ruck::UGen::InChannel.new
+
+filenames = ARGV
+filenames.each do |filename|
+  unless File.readable?(filename)
+    LOG.fatal "Cannot read file #{filename}"
+    exit
+  end
+end
+
+filenames.each do |filename|
+  SHREDULER.spork(filename) do
+    include Ruck::UGen::ShredLocal
+    include Ruck::UGen::Generators
+    require filename
+  end
+end
+SHREDULER.run

data/examples/ex01.rb

@@ -0,0 +1,24 @@
+def beep(wav, chan)
+  (s = SawOsc.new(:freq => 440, :gain => 0.25)) >> wav.in(chan)
+  10.times do
+    play 0.1.seconds
+    s.freq *= 1.2
+  end
+  s << wav
+end
+
+wav = WavOut.new(:filename => "ex01.wav", :num_channels => 2)
+SinOsc.new(:freq => 440, :gain => 0.25) >> wav
+SinOsc.new(:freq => 880, :gain => 0.25) >> wav
+
+wav >> blackhole
+
+chan = 0
+
+10.times do
+  play 0.7.seconds
+  chan = (chan + 1) % 2
+  spork("beep") { beep(wav, chan) }
+end
+
+play 2.seconds

data/examples/ex02.rb

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

data/examples/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/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/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/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/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/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/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/ex10.rb

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

data/examples/ex11.rb

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

data/lib/ruck/misc/linkage.rb

@@ -0,0 +1,52 @@
+
+# linkable_attr generates accessor methods for
+# instance variables that behaves almost like
+# attr_accessor.
+
+# The difference is that if an object is assigned
+# which responds to :call, accessing the method
+# returns the result of invoking :call instead of
+# the Proc/lambda/block itself.
+
+# relies on _why's metaid, included below.
+
+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
+
+# stolen from metaid.rb:
+# http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+# (that site does not exist, but a mirror can be found)
+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/riff.rb

@@ -0,0 +1,101 @@
+
+# module for parsing RIFF files (the binary protocol
+# used for packets in a WAV file, for example)
+
+# get an array of all the RIFF chunks in a file:
+#   RiffReader.new("file.wav").chunks
+
+# this library avoids loading the entire file into
+# memory by LEAVING THE FILE OPEN FOR READING FOREVER.
+
+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
+      return nil if @fn.closed?
+      
+      @fn.seek @start
+      @type = @fn.read(4)
+    end
+    
+    def size
+      return @size - @data_skip if @size
+      return nil if @fn.closed?
+      
+      @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)
+      return if @fn.closed?
+      
+      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
+      return @chunks if @chunks
+      return [] if @fn.closed?
+      
+      offset = @data_start + @data_skip
+      @chunks = []
+      while offset + @data_skip - @data_start < size
+        chunk = RiffReaderChunk.new(@fn, offset)
+        @chunks << chunk
+        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
+      return @chunks if @chunks
+      return [] if @fn.closed?
+      
+      offset = 0
+      @chunks = []
+      until @fn.eof?
+        chunk = RiffReaderChunk.new(@fn, offset)
+        @chunks << chunk
+        offset += 8 + chunk.size
+        @fn.seek offset + 8
+      end
+      
+      @chunks
+    end
+    
+    def close
+      @fn.close unless @fn.closed?
+    end
+    
+  end
+  
+end