ruck 0.1.2 → 0.2.0

data/lib/ruck/misc/linkage.rb

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

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

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

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

@@ -1,35 +0,0 @@
-# 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/ugen/general.rb

@@ -1,408 +0,0 @@
-
-module Ruck
-
-  module UGen
-
-    def to_s
-      "<#{self.class}" +
-        (name ? "(#{name})" : "") +
-        " #{attr_names.map { |a| "#{a}:#{send a}" }.join " "}>"
-    end
-
-    attr_accessor :name
-
-  protected
-
-    def require_attrs(attrs, names)
-      names.each do |name|
-        unless attrs.has_key? name
-          raise "#{self} requires attribute #{name}"
-        end
-      end
-    end
-
-    def parse_attrs(attrs)
-      attrs.each do |attr, value|
-        send("#{attr}=", value)
-      end
-    end
-
-    def pop_attrs(attrs, names)
-      names.map { |name| attrs.delete(name) }
-    end
-
-  end
-
-  module Target
-    def add_source(ugen)
-      if ugen.is_a? Array
-        ugen.each { |u| add_source u }
-      else
-        @ins << ugen
-      end
-      
-      self
-    end
-
-    def remove_source(ugen)
-      if ugen.is_a? Array
-        ugen.each { |u| remove_source u }
-      else
-        @ins.delete(ugen)
-      end
-      
-      self
-    end
-  end
-
-  module MultiChannelTarget
-    def add_source(ugen)
-      if ugen.is_a? Array
-        ugen.each { |u| add_source u }
-        return self
-      end
-      
-      if ugen.out_channels.length == 1
-        @in_channels.each { |chan| chan.add_source ugen.out(0) }
-      else
-        1.upto([ugen.out_channels.length, @in_channels.length].min) do |i|
-          @in_channels[i-1].add_source ugen.out(i-1)
-        end
-      end
-      
-      self
-    end
-
-    def remove_source(ugen)
-      if ugen.is_a? Array
-        ugen.each { |u| remove_source u }
-        return
-      end
-      
-      # remove all outputs of ugen from all inputs of self
-      @in_channels.each do |in_chan|
-        ugen.out_channels.each do |out_chan|
-          in_chan.remove_source out_chan
-        end
-      end
-      
-      self
-    end
-    
-    def in_channels
-      @in_channels
-    end
-
-    def in(chan)
-      @in_channels[chan]
-    end
-  end
-
-  module Source
-    def >>(ugen)
-      ugen.add_source self
-    end
-
-    def <<(ugen)
-      ugen.remove_source self
-    end
-    
-    def out_channels
-      [self]
-    end
-
-    def out(chan)
-      self if chan == 0
-    end
-
-    def next(now); @last; end
-    def last; @last; end
-  end
-
-  module MultiChannelSource
-    def >>(ugen)
-      ugen.add_source self
-    end
-
-    def <<(ugen)
-      ugen.remove_source self
-    end
-    
-    def out_channels
-      @out_channels
-    end
-    
-    def out(chan)
-      @out_channels[chan]
-    end
-
-    def next(now, chan = 0); @last[chan]; end
-    def last(chan = 0); @last[chan]; end
-  end
-
-  class InChannel
-    include UGen
-    include Target
-
-    def initialize(attrs = {})
-      parse_attrs attrs
-      @ins = []
-      @last = 0.0
-    end
-
-    def next(now)
-      return @last if @now == now
-      @now = now
-      @last = @ins.inject(0) { |samp, ugen| samp += ugen.next(now) }
-    end
-
-    def attr_names
-      []
-    end
-  end
-
-  class OutChannel
-    include Source
-
-    def initialize(parent, channel_number)
-      @parent = parent
-      @channel_number = channel_number
-    end
-
-    def next(now)
-      return @last if @now == now
-      @last = @parent.next(now, @channel_number)
-    end
-  end
-
-  module Generators
-    
-    class Gain
-      include UGen
-      include Source
-      include Target
-
-      linkable_attr :gain
-
-      def initialize(attrs = {})
-        parse_attrs({ :gain => 1.0 }.merge(attrs))
-        @ins = []
-        @last = 0.0
-      end
-
-      def next(now)
-        return @last if @now == now
-        @now = now
-        @last = @ins.inject(0) { |samp, ugen| samp += ugen.next(now) } * gain
-      end
-
-      def attr_names
-        [:gain]
-      end
-    end
-
-    class Step
-      include UGen
-      include Source
-
-      linkable_attr :value
-
-      def initialize(attrs = {})
-        parse_attrs({ :value => 0.0 }.merge(attrs))
-        @last = value
-      end
-
-      def next(now)
-        return @last if @now == now
-        @now = now
-        @last = value
-      end
-
-      def attr_names
-        [:value]
-      end
-    end
-
-    class Delay
-      include UGen
-      include Target
-      include Source
-
-      linkable_attr :gain
-
-      def initialize(attrs = {})
-        require_attrs attrs, [:time]
-        samples = attrs.delete(:time)
-        parse_attrs attrs
-        @ins = []
-        @last = 0.0
-        @queue = [0.0] * samples
-      end
-
-      def next(now)
-        return @last if @now == now
-        @now = now
-
-        @queue << @ins.inject(0) { |samp, ugen| samp += ugen.next(now) } * gain
-        @last = @queue.shift
-      end
-
-      def attr_names
-        [:time]
-      end
-    end
-
-    class Noise
-      include UGen
-      include Source
-
-      linkable_attr :gain
-
-      def initialize(attrs = {})
-        parse_attrs({ :gain => 1.0 }.merge(attrs))
-        @last = 0.0
-      end
-
-      def next(now)
-        return @last if @now == now
-        @now = now
-        @last = rand * gain
-      end
-
-      def attr_names
-        [:gain]
-      end
-    end
-
-    class Ramp
-      include UGen
-      include Source
-
-      linkable_attr :from
-      linkable_attr :to
-      linkable_attr :duration
-      linkable_attr :progress
-      linkable_attr :paused
-
-      def initialize(attrs = {})
-        parse_attrs({ :from => 0.0,
-                      :to => 1.0,
-                      :duration => 1.second }.merge(attrs))
-        @progress = 0.0
-        @paused = false
-        @last = 0.0
-      end
-
-      def next(now)
-        return @last if @now == now
-        @now = now
-        @last = progress * (to - from) + from
-        inc_progress
-        @last
-      end
-
-      def reverse
-        @from, @to = @to, @from
-      end
-
-      def reset
-        @progress = 0.0
-      end
-
-      def finished?
-        progress == 1.0
-      end
-
-      def attr_names
-        [:from, :to, :duration, :progress, :paused]
-      end
-
-      protected
-
-        def inc_progress
-          return if @paused
-          @progress += 1.0 / duration
-          @progress = 1.0 if @progress > 1.0
-        end
-
-    end
-
-    class ADSR
-      include UGen
-      include Target
-      include Source
-
-      attr_accessor :attack_time
-      attr_accessor :attack_gain
-      attr_accessor :decay_time
-      attr_accessor :sustain_gain
-      attr_accessor :release_time
-
-      def initialize(attrs = {})
-        parse_attrs({ :attack_time => 50.ms,
-                      :attack_gain => 1.0,
-                      :decay_time => 50.ms,
-                      :sustain_gain => 0.5,
-                      :release_time => 500.ms }.merge(attrs))
-
-        @ramp = Ramp.new
-
-        @ins = []
-        @last = 0.0
-        @gain = 0.0
-        @state = :idle
-      end
-
-      def next(now)
-        return @last if @now == now
-        @now = now
-        @gain = case @state
-                when :idle
-                  0
-                when :attack
-                  if @ramp.finished?
-                    @ramp.reset
-                    @ramp.from, @ramp.to = @ramp.last, @sustain_gain
-                    @ramp.duration = @decay_time
-                    @state = :decay
-                  end
-                  @ramp.next(now)
-                when :decay
-                  @state = :sustain if @ramp.finished?
-                  @ramp.next(now)
-                when :sustain
-                  @sustain_gain
-                when :release
-                  @state = :idle if @ramp.finished?
-                  @ramp.next(now)
-                end
-        @last = @ins.inject(0) { |samp, ugen| samp += ugen.next(now) } * @gain
-      end
-
-      def on
-        @ramp.reset
-        @ramp.from, @ramp.to = @gain, @attack_gain
-        @ramp.duration = @attack_time
-        @state = :attack
-      end
-
-      def off
-        @ramp.reset
-        @ramp.from, @ramp.to = @gain, 0
-        @ramp.duration = @release_time
-        @state = :release
-      end
-
-      def attr_names
-        [:attack_time, :attack_gain, :decay_time, :sustain_gain, :release_time]
-      end
-
-    end
-  end
-
-end
-
-# Allow chucking all elements of an array to
-class Array
-  include Ruck::Source
-end

data/lib/ruck/ugen/oscillators.rb

@@ -1,106 +0,0 @@
-
-module Ruck
-  
-  module Oscillator
-    include UGen
-    TWO_PI = 2 * Math::PI
-  
-    def self.included(base)
-      base.instance_eval do
-        linkable_attr :freq
-        linkable_attr :phase
-      end
-    end
-  
-    def phase_forward
-      @phase = (@phase + freq.to_f / SAMPLE_RATE.to_f) % 1.0
-    end
-  end
-  
-  module Generators
-    
-    class SinOsc
-      include Source
-      include Oscillator
-
-      linkable_attr :freq
-      linkable_attr :gain
-
-      def initialize(attrs = {})
-        parse_attrs({ :freq => 440.0,
-                      :gain => 1.0 }.merge(attrs))
-        @phase = 0.0
-        @last = 0.0
-      end
-
-      def next(now)
-        return @last if @now == now
-        @now = now
-        @last = gain * Math.sin(phase * TWO_PI)
-        phase_forward
-        @last
-      end
-    
-      def attr_names
-        [:freq, :gain, :phase]
-      end
-    end
-
-    class SawOsc
-      include Source
-      include Oscillator
-
-      linkable_attr :gain
-
-      def initialize(attrs = {})
-        parse_attrs({ :freq => 440.0,
-                      :gain => 1.0 }.merge(attrs))
-        @phase = 0.0
-        @last = 0.0
-      end
-
-      def next(now)
-        return @last if @now == now
-        @now = now
-        @last = ((phase * 2.0) - 1.0) * gain
-        phase_forward
-        @last
-      end
-    
-      def attr_names
-        [:freq, :gain, :phase]
-      end
-    end
-
-    class TriOsc
-      include Source
-      include Oscillator
-
-      linkable_attr :gain
-
-      def initialize(attrs = {})
-        parse_attrs({ :freq => 440.0,
-                      :gain => 1.0 }.merge(attrs))
-        @phase = 0.0
-        @last = 0.0
-      end
-
-      def next(now)
-        return @last if @now == now
-        @now = now
-        @last = if phase < 0.5
-          phase * 4.0 - 1.0
-        else
-          1.0 - ((phase - 0.5) * 4.0)
-        end * gain
-        phase_forward
-        @last
-      end
-    
-      def attr_names
-        [:freq, :gain, :phase]
-      end
-    end
-    
-  end
-end