ruck 0.1.2 → 0.2.0

data/bin/ruck_midi

@@ -1,151 +0,0 @@
-#!/usr/bin/env ruby
-$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-
-require "ruck"
-
-require "rubygems"
-require "midilib"
-require "midiator"
-
-# configuration
-if ARGV.length < 4
-  puts "ruby midilib_runner.rb MIDI_FILENAME NUM_TRACKS LIVE SCRIPT_FILENAME [...]"
-  exit 1
-end
-
-MIDI_FILENAME = ARGV[0]
-NUM_TRACKS = ARGV[1].to_i
-ALSO_LIVE = ["yes", "true", "1", "yeah"].include? ARGV[2].downcase
-FILENAMES = ARGV[3..-1]
-
-class MIDIShreduler < Ruck::Shreduler
-  def run
-    @start_time = Time.now
-    super
-  end
-  
-  def sim_to(new_now)
-    d = new_now - @now
-    TRACK_DELTAS.each_with_index do |delta, i|
-      TRACK_DELTAS[i] = delta + d
-    end
-    
-    # sync with wall clock
-    if ALSO_LIVE
-      actual_now = Time.now
-      simulated_now = @start_time + (new_now.to_f / SEQUENCE.ppqn / SEQUENCE.bpm * 60.0)
-      if simulated_now > actual_now
-        sleep(simulated_now - actual_now)
-      end
-    end
-    
-    @now = new_now
-  end
-end
-
-# state
-SHREDULER = MIDIShreduler.new
-SEQUENCE = MIDI::Sequence.new
-TRACKS = (1..NUM_TRACKS).map { MIDI::Track.new(SEQUENCE) }
-TRACK_DELTAS = TRACKS.map { 0 }
-if ALSO_LIVE
-  MIDI_PLAYER = MIDIator::Interface.new
-end
-
-# midi initialization stuff
-TRACKS.each do |track|
-  SEQUENCE.tracks << track
-  #track.events << MIDI::Tempo.new(MIDI::Tempo.bpm_to_mpq(120))
-end
-if ALSO_LIVE
-  MIDI_PLAYER.use :dls_synth
-  MIDI_PLAYER.instruct_user!
-end
-
-# set up some useful time helpers
-module MIDITime
-  def pulse
-    self
-  end
-  alias_method :pulses, :pulse
-  
-  def quarter_note
-    self * SEQUENCE.ppqn
-  end
-  alias_method :quarter_notes, :quarter_note
-  alias_method :beat, :quarter_note
-  alias_method :beats, :quarter_note
-end
-
-class Fixnum
-  include MIDITime
-end
-
-class Float
-  include MIDITime
-end
-
-# stuff accessible in a shred
-module ShredLocal
-
-  def now
-    SHREDULER.now
-  end
-
-  def spork(name = "unnamed", &shred)
-    SHREDULER.spork(name, &shred)
-  end
-
-  def wait(pulses)
-    SHREDULER.current_shred.yield(pulses)
-  end
-
-  def finish
-    shred = SHREDULER.current_shred
-    SHREDULER.remove_shred shred
-    shred.finish
-  end
-  
-  def note_on(note, velocity = 127, channel = 0, track = 0)
-    TRACKS[track].events << MIDI::NoteOnEvent.new(channel, note, velocity, TRACK_DELTAS[track].to_i)
-    TRACK_DELTAS[track] = 0
-    if ALSO_LIVE
-      MIDI_PLAYER.driver.note_on(note, channel, velocity)
-    end
-  end
-  
-  def note_off(note, channel = 0, track = 0)
-    TRACKS[track].events << MIDI::NoteOffEvent.new(channel, note, 0, TRACK_DELTAS[track].to_i)
-    TRACK_DELTAS[track] = 0
-    if ALSO_LIVE
-      MIDI_PLAYER.driver.note_on(note, channel, 0)
-    end
-  end
-
-end
-
-def save
-  return if @saved
-  @saved = true
-  File.open(MIDI_FILENAME, "wb") { |file| SEQUENCE.write(file) }
-end
-
-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 ShredLocal
-    require filename
-  end
-end
-
-at_exit { save }
-
-SHREDULER.run
-
-save

data/bin/ruck_sleep

@@ -1,47 +0,0 @@
-#!/usr/bin/env ruby
-$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-
-require "ruck"
-
-# stuff accessible in a shred
-module ShredLocal
-  
-  def now
-    SHREDULER.now
-  end
-
-  def spork(name = "unnamed", &shred)
-    SHREDULER.spork(name, &shred)
-  end
-
-  def wait(seconds)
-    SHREDULER.current_shred.yield(seconds)
-  end
-
-  def finish
-    shred = SHREDULER.current_shred
-    SHREDULER.remove_shred shred
-    shred.finish
-  end
-
-end
-
-
-SAMPLE_RATE = 1
-SHREDULER = Ruck::RealTimeShreduler.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 ShredLocal
-    require filename
-  end
-end
-SHREDULER.run

data/bin/ruck_ugen

@@ -1,53 +0,0 @@
-#!/usr/bin/env ruby
-$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-
-require "ruck"
-
-# stuff accessible in a shred
-module ShredLocal
-
-  def blackhole
-    BLACKHOLE
-  end
-  
-  def now
-    SHREDULER.now
-  end
-
-  def spork(name = "unnamed", &shred)
-    SHREDULER.spork(name, &shred)
-  end
-
-  def play(samples)
-    SHREDULER.current_shred.yield(samples)
-  end
-
-  def finish
-    shred = SHREDULER.current_shred
-    SHREDULER.remove_shred shred
-    shred.finish
-  end
-
-end
-
-
-SAMPLE_RATE = 22050
-SHREDULER = Ruck::UGenShreduler.new
-BLACKHOLE = Ruck::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 ShredLocal
-    include Ruck::Generators
-    require filename
-  end
-end
-SHREDULER.run

data/examples/glapp/ex01.rb

@@ -1,28 +0,0 @@
-
-clear
-
-spork("framerate watcher") do
-  start_time = Time.now
-  frames = 0
-  
-  loop do
-    wait_for_frame
-    frames += 1
-    if frames % 100 == 0
-      puts "#{frames.to_f / (Time.now - start_time)}"
-    end
-  end
-  
-end
-
-loop do
-  wait 2
-  
-  glColor 1, 0, 0
-  glTranslate(0, 0, -5)
-  glutSolidCube(2)
-  
-  wait 0.1
-  
-  clear
-end

data/examples/glapp/ex02.rb

@@ -1,57 +0,0 @@
-
-require "rubygems"
-require "midiator"
-
-$midi = MIDIator::Interface.new
-$midi.use :dls_synth
-$midi.instruct_user!
-
-def note_on(note, velocity = 127, channel = 0)
-  $midi.driver.note_on(note, channel, velocity)
-end
-
-def note_off(note, channel = 0)
-  $midi.driver.note_on(note, channel, 0)
-end
-
-def star_shifter(key)
-  wait 3
-  @stars.shift
-  note_off(key)
-end
-
-spork do
-  while ev = wait_for_key_down
-    note_on(ev.key)
-
-    @stars << Star.new
-    spork { star_shifter ev.key }
-  end
-end
-
-spork do
-  while ev = wait_for_key_up
-  end
-end
-
-class Star
-  def initialize
-    @x = rand * 2 - 1
-    @y = rand * 2 - 1
-  end
-  
-  def draw
-    glPushMatrix
-      glTranslate @x, @y, -5
-      glutSolidCube(0.1)
-    glPopMatrix
-  end
-end
-
-clear
-
-@stars = []
-while wait_for_frame
-  clear
-  @stars.each { |star| star.draw }
-end

data/examples/glapp/ex03.rb

@@ -1,9 +0,0 @@
-
-spork do
-  loop do
-    ev = wait_for_key_down
-    puts "you pressed #{ev.key}"
-  end
-end
-
-clear

data/examples/midi/ex01.rb

@@ -1,24 +0,0 @@
-
-def maybe
-  rand >= 0.5
-end
-
-TRACKS[0].events << MIDI::Controller.new(10, 32, 1) # channel, controller, value
-TRACKS[0].events << MIDI::ProgramChange.new(10, 26) # channel, program
-MIDI_PLAYER.control_change 32, 10, 1 # number, channel, value
-MIDI_PLAYER.program_change 10, 26 # channel, program
-
-def play(note, dur = 1.quarter_note)
-  return if maybe
-  note_on note, 100, 10
-  wait dur
-  note_off note, 10
-end
-
-10.times do
-  spork { play(rand(30) + 40, rand * 3.quarter_notes + 3.quarter_notes) }
-  wait 0.5.quarter_note
-end
-
-wait 2.quarter_notes; note_off 0 # end padding
-

data/examples/midi/ex02.rb

@@ -1,72 +0,0 @@
-
-def maybe
-  rand >= 0.5
-end
-
-@base = 43
-@scale = 0
-@chord = 0
-
-major_scale = [0, 2, 4, 5, 7, 9, 11]
-minor_scale = [0, 2, 3, 5, 7, 8, 11]
-@scales = [major_scale, minor_scale]
-
-def scale(note, scale)
-  len = scale.length
-  oct = note / len
-  off = note % len
-  while off < 0
-    off += len
-    oct -= 1
-  end
-  oct * 12 + scale[off]
-end
-
-def play(note, dur = 1.beat)
-  midi_note = @base + scale(note, @scales[@scale])
-  note_on midi_note, 100
-  wait dur
-  note_off midi_note
-end
-
-def change_chords
-  loop do
-    wait 4.beats
-    @chord = rand(7)
-    if rand <= 0.1
-      @scale = (@scale + 1) % @scales.length
-    end
-  end
-end
-
-def play_chord(dur)
-  spork { play(@chord, dur) }
-  spork { play(@chord + 2, dur) }
-  spork { play(@chord + 4, dur) }
-end
-
-def play_chords
-  loop do
-    if maybe && maybe
-      play_chord 2.beats
-      wait 2.beats
-      play_chord 2.beats
-      wait 2.beats
-    else
-      play_chord 4.beats
-      wait 4.beats
-    end
-  end
-end
-
-def play_melody
-  loop do
-    len = ((rand(2) + 1) / 2.0).beats
-    play(@chord + 7 + 2 * rand(4), len)
-    wait len
-  end
-end
-
-spork { change_chords }
-spork { play_chords }
-spork { play_melody }

data/examples/ugen/ex01.rb

@@ -1,24 +0,0 @@
-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/ugen/ex02.rb

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

data/examples/ugen/ex03.rb

@@ -1,8 +0,0 @@
-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

@@ -1,14 +0,0 @@
-(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

@@ -1,9 +0,0 @@
-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

@@ -1,10 +0,0 @@
-# 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

@@ -1,35 +0,0 @@
-@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

@@ -1,28 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-# 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

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

data/examples/ugen/ex11.rb

@@ -1,10 +0,0 @@
-# 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

@@ -1,9 +0,0 @@
-# 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/bench.rb

@@ -1,44 +0,0 @@
-
-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