scruby 0.2.7

data/lib/scruby/core_ext/typed_array.rb

@@ -0,0 +1,54 @@
+
+# Typed array is a kind of Array that only accepts elements of a given Class, it will raise a TypeError if an element of 
+# diferent Class is passed to the operation methods or if an Array containing objects of a diferent class is concatenated.
+class TypedArray < Array
+  attr_reader :type
+  
+  # +Type+ a Class or an instance, on the operation methods it will match the argument against the Class or instance's Class
+  def initialize type, elements = []
+    @type = type.instance_of?(Class) ? type : type.class
+    check_array_passed elements
+    check_types_for_array elements
+    super elements
+  end
+  
+  # alias :old_plus :+ #:nodoc:
+  # 
+  # def + array
+  #   self.class.new @type, self.old_plus( array )
+  # end
+  
+  def concat array
+    check_array_passed array
+    check_types_for_array array
+    super
+  end
+  
+  def << e
+    check_type_for_obj e
+    super
+  end
+  
+  def []= index, e
+    check_type_for_obj e
+    super
+  end
+  
+  def push e
+    check_type_for_obj e
+    super
+  end
+  
+  private
+  def check_array_passed obj
+    raise TypeError.new( "#{obj} is not Array" ) unless obj.instance_of? Array
+  end
+  
+  def check_types_for_array array
+    raise TypeError.new("All elements of #{array} should be instance of #{@type}") unless array.reject{ |e| e.instance_of? @type }.empty?
+  end
+  
+  def check_type_for_obj obj
+    raise TypeError.new("#{obj} is not instance of #{@type}") unless obj.instance_of? @type
+  end
+end

data/lib/scruby/env.rb

@@ -0,0 +1,93 @@
+module Scruby
+  class Env
+    attr_accessor :levels, :times, :curves, :release_node, :array
+    SHAPE_NAMES = {
+      :step        => 0,
+      :lin         => 1,
+      :linear      => 1,
+      :exp         => 2,
+      :exponential => 2,
+      :sin         => 3,
+      :sine        => 3,
+      :wel         => 4,
+      :welch       => 4,
+      :sqr         => 6,
+      :squared     => 6,
+      :cub         => 7,
+      :cubed       => 7
+    }
+
+    def initialize levels, times, curves = :lin, release_node = nil, loop_node = nil
+      #times should be one less than levels size
+      # raise( ArgumentError, 'levels and times must be array')
+      @levels, @times, @curves, @release_node, @loop_node = levels, times, curves.to_array, release_node, loop_node
+      raise ArgumentError, "levels and times should be array" unless levels.kind_of?(Array) and times.kind_of?(Array)
+    end
+
+    class << self
+      def triangle dur = 1, level = 1
+        dur = dur * 0.5
+        new [0, level, 0], [dur, dur]
+      end
+
+      def sine dur = 1, level = 1
+        dur = dur * 0.5
+        new [0, level, 0], [dur, dur], :sine
+      end
+
+      def perc attackTime = 0.01, releaseTime = 1, level = 1, curve = -4
+        new [0, level, 0], [attackTime, releaseTime], curve
+      end
+
+      def linen attackTime = 0.01, sustainTime = 1, releaseTime = 1, level = 1, curve = :lin
+        new [0, level, level, 0], [attackTime, sustainTime, releaseTime], curve
+      end
+
+      def cutoff releaseTime = 0.1, level = 1, curve = :lin
+        new [level, 0], [releaseTime], curve, 0
+      end
+
+      def dadsr delayTime = 0.1, attackTime = 0.01, decayTime = 0.3, sustainLevel = 0.5, releaseTime = 1, peakLevel = 1, curve = -4, bias = 0
+        new [0, 0, peakLevel, peakLevel * sustainLevel, 0].collect{ |e| e + bias }, [delayTime, attackTime, decayTime, releaseTime], curve, 3
+      end
+
+      def adsr attackTime = 0.01, decayTime = 0.3, sustainLevel = 0.5, releaseTime = 1, peakLevel = 1, curve = -4, bias = 0
+        new [0, peakLevel, peakLevel * sustainLevel, 0].collect{ |e| e + bias }, [attackTime, decayTime, releaseTime], curve, 2
+      end
+
+      def asr attackTime = 0.01, sustainLevel = 1, releaseTime = 1, curve = -4
+        new [0, sustainLevel, 0], [attackTime, releaseTime], curve, 1
+      end
+
+      named_arguments_for :triangle, :sine, :perc, :linen, :cutoff, :dadsr, :adsr, :asr
+    end
+
+    def to_array
+      contents = levels[0], times.size, release_node, loop_node
+      contents + levels[1..-1].wrap_and_zip( times, shape_numbers, curve_values ).flatten
+    end
+
+    def shape_numbers
+      curves.collect do |curve|
+        Ugens::Ugen.valid_input?( curve ) ? 5 : SHAPE_NAMES[curve]
+      end
+    end
+
+    def curve_values
+      curves.collect do |curve|
+        Ugens::Ugen.valid_input?( curve ) ? curve : 0
+      end
+    end
+
+    def release_node
+      @release_node ||= -99
+    end
+
+    def loop_node
+      @loop_node ||= -99
+    end
+
+    def collect_constants #:nodoc:
+    end
+  end
+end

data/lib/scruby/group.rb

@@ -0,0 +1,24 @@
+module Scruby
+  class Group < Node
+    
+    def free_all
+      send '/g_freeAll', self.id
+      self
+    end
+    
+    def deep_free
+      send '/g_deepFree', self.id
+      self
+    end
+    
+    def dump_tree post = false
+      send '/g_dumpTree', self.id, post
+      self
+    end
+    
+    class << self
+      
+    end
+    
+  end
+end

data/lib/scruby/node.rb

@@ -0,0 +1,102 @@
+module Scruby
+  class Node
+    @@base_id = 999
+    attr_reader :servers, :group, :id
+    
+    ACTIONS = [:head, :tail, :before, :after, :replace]
+
+    def initialize *args
+      args.flatten!
+      args.compact!
+      args.each{ |s| raise TypeError.new("#{s} should be instance of Server") unless Server === s }
+      @id      = args.pop if args.last.is_a? Integer
+      @servers = args.empty? ? Server.all : args
+      @id    ||= @@base_id += 1
+    end
+    
+    def set args = {}
+      send '/n_set', self.id, *args.to_a.flatten
+      self
+    end
+
+    def free
+      send '/n_free', self.id
+      @group, @playing, @running = nil, false, false
+      self
+    end
+    
+    def run run = true
+      send '/n_run', self.id, run
+      self
+    end
+    
+    # Map controls in this Node to read from control or audio rate Buses. Controls are defined in a SynthDef as args or instances of
+    # Control or its subclasses. They are specified here using symbols, strings, or indices, and are listed in pairs with Bus objects.
+    # The number of sequential controls mapped corresponds to the Bus' number of channels. If this Node is a Group this will map all
+    # Nodes within the Group. Note that with mapMsg if you mix audio and control rate busses you will get an Array of two messages
+    # rather than a single message. Integer bus indices are assumed to refer to control buses. To map a control to an audio bus, you
+    # must use a Bus object.
+    def map args
+      control, audio, content = ['/n_mapn', self.id], ['/n_mapan', self.id], []
+      args    = args.to_a.each do |param, bus|
+        raise ArgumentError, "`#{ control }` is not a Bus" unless bus.kind_of? Bus
+        array = audio   if bus.rate == :audio
+        array = control if bus.rate == :control
+        array.push param, bus.index, bus.channels if array
+      end
+      content << control unless control.empty?
+      content << audio   unless audio.empty?
+      send_bundle nil, *content
+      self
+    end
+    
+    # mapn
+    def trace
+      send '/n_trace', self.id
+      self
+    end
+    
+    def move_before node
+      @group = node.group
+      send '/n_before', self.id, node.id
+      self
+    end
+    
+    def move_after node
+      @group = node.group
+      send '/n_after', self.id, node.id
+      self
+    end
+    
+    # def move_to_head group
+    #   @group = node.group
+    #   @server.each{ |s| s.send '/n_after', self.id, node.id }
+    # end
+    # 
+    # def move_to_tail group
+    #   @group = node.group
+    #   @server.each{ |s| s.send '/n_after', self.id, node.id }
+    # end
+
+    def playing?; @playing || false; end
+    alias :running? :playing?
+
+    # Reset the node count
+    def self.reset!
+      @@base_id = 2000
+    end
+    
+    # Sends a bundle to all registered +servers+ for this node
+    def send_bundle timestamp, *messages
+      bundle = Bundle.new( timestamp, *messages.map{ |message| Message.new *message } )
+      @servers.each{ |s| s.send bundle  }
+    end
+    
+    # Sends a message to all registered +servers+ for this node
+    def send command, *args
+      message = Message.new command, *args
+      @servers.each{ |s| s.send message }
+      self
+    end
+  end
+end

data/lib/scruby/server.rb

@@ -0,0 +1,182 @@
+require 'singleton'
+
+module Scruby 
+  include OSC
+  
+  TrueClass.send :include, OSC::OSCArgument
+  TrueClass.send(:define_method, :to_osc_type){ 1 }
+  
+  FalseClass.send :include, OSC::OSCArgument
+  FalseClass.send(:define_method, :to_osc_type){ 0 }
+  
+  Hash.send :include, OSC::OSCArgument
+  Hash.send :define_method, :to_osc_type do 
+    self.to_a.collect{ |pair| pair.collect{ |a| OSC.coerce_argument a } }
+  end
+
+  Array.send(:include, OSC::OSCArgument)
+  Array.send( :define_method, :to_osc_type) do
+    Blob.new Message.new(*self).encode
+  end
+
+  class Server
+    attr_reader :host, :port, :path, :buffers, :control_buses, :audio_buses
+    DEFAULTS = { :buffers => 1024, :control_buses => 4096, :audio_buses => 128, :audio_outputs => 8, :audio_inputs => 8, 
+      :host => 'localhost', :port => 57111, :path => '/Applications/SuperCollider/scsynth'
+      }
+
+    # Initializes and registers a new Server instance and sets the host and port for it.
+    # The server is a Ruby representation of scsynth which can be a local binary or a remote    
+    # server already running.
+    # Server class keeps an array with all the instantiated servers
+    #   Options:
+    #     +host+: 
+    #       defaults to 'localhost'
+    #     +port+:
+    #       TCP port defaults to 57111
+    #     +control_buses+
+    #       Number of buses for routing control data defaults to 4096, indices start at 0.
+    #     +audio_buses+
+    #       Number of audio Bus channels for hardware output and input and internal routing, defaults to 128
+    #     +audio_outputs+
+    #       Reserved +buses+ for hardware output, indices available are 0 to +audio_outputs+ - 1 defaults to 8.
+    #     +audio_inputs+
+    #       Reserved +buses+ for hardware input, +audio_outputs+ to (+audio_outputs+ + +audio_inputs+ - 1), defaults to 8.
+    #     +buffers+
+    #       Number of available sample buffers defaults to 1024
+    def initialize opts = {}
+      @opts          = DEFAULTS.dup.merge opts
+      @buffers       = []
+      @control_buses = []
+      @audio_buses   = []
+      @client        = Client.new port, host
+      Bus.audio self, @opts[:audio_outputs] # register hardware buses
+      Bus.audio self, @opts[:audio_inputs]
+      self.class.all << self
+    end
+    
+    def host; @opts[:host]; end
+    def port; @opts[:port]; end
+    def path; @opts[:path]; end
+
+    # Boots the local binary of the scsynth forking a process, it will rise a SCError if the scsynth 
+    # binary is not found in /Applications/SuperCollider/scsynth (default Mac OS path) or given path. 
+    # The default path can be overriden using Server.scsynt_path=('path')
+    def boot
+      raise SCError.new('Scsynth not found in the given path') unless File.exists? path
+      if running?
+        warn "Server on port #{ port } allready running"
+        return self 
+      end
+
+      ready   = false
+      timeout = Time.now + 2
+      @thread = Thread.new do
+        IO.popen "cd #{ File.dirname path }; ./#{ File.basename path } -u #{ port }" do |pipe|
+          loop do 
+            if response = pipe.gets
+              puts response
+              ready = true if response.match /ready/
+            end
+          end
+        end
+      end
+      sleep 0.01 until ready or !@thread.alive? or Time.now > timeout
+      sleep 0.01        # just to be shure
+      send "/g_new", 1  # default group
+      self   
+    end
+
+    def running?
+      @thread and @thread.alive? ? true : false
+    end
+
+    def stop
+      send "/g_freeAll", 0
+      send "/clearSched"
+      send "/g_new", 1
+    end
+    alias :panic :stop
+
+    # Sends the /quit OSC signal to the scsynth
+    def quit
+      Server.all.delete self
+      send '/quit'
+    end
+
+    # Sends an OSC command or +Message+ to the scsyth server.
+    # E.g. +server.send('/dumpOSC', 1)+
+    def send message, *args
+      message = Message.new message, *args unless Message === message or Bundle === message
+      @client.send message
+    end
+
+    def send_bundle timestamp = nil, *messages
+      send Bundle.new( timestamp, *messages.map{ |message| Message.new *message  } )
+    end
+
+    # Encodes and sends a SynthDef to the scsynth server
+    def send_synth_def synth_def
+      send Bundle.new( nil, Message.new('/d_recv', Blob.new(synth_def.encode), 0) )
+    end
+
+    # Allocates either buffer or bus indices, should be consecutive
+    def allocate kind, *elements
+      collection = instance_variable_get "@#{kind}"
+      elements.flatten!
+
+      max_size = @opts[kind]
+      if collection.compact.size + elements.size > max_size
+        raise SCError, "No more indices available -- free some #{ kind } before allocating more."
+      end
+
+      return collection.concat(elements) unless collection.index nil # just concat arrays if no nil item
+
+      indices = []
+      collection.each_with_index do |item, index| # find n number of consecutive nil indices
+        break if indices.size >= elements.size
+        if item.nil?
+          indices << index
+        else
+          indices.clear
+        end
+      end
+
+      case 
+      when indices.size >= elements.size
+        collection[indices.first, elements.size] = elements
+      when collection.size + elements.size <= max_size
+        collection.concat elements
+      else
+        raise SCError, "No block of #{ elements.size } consecutive #{ kind } indices is available."
+      end
+    end
+
+    @@servers = []
+    class << self
+      # Returns an array with all the registered servers
+      def all
+        @@servers
+      end
+
+      # Clear the servers array
+      def clear
+        @@servers.clear
+      end
+
+      # Return a server corresponding to the specified index of the registered servers array
+      def [] index
+        @@servers[index]
+      end
+
+      # Set a server to the specified index of the registered servers array
+      def []= index
+        @@servers[index]
+        @@servers.uniq!
+      end
+    end
+  end
+
+  class SCError < StandardError
+  end
+end

data/lib/scruby/synth.rb

@@ -0,0 +1,50 @@
+module Scruby
+  class Synth < Node
+    attr_reader :name
+
+    def initialize name, servers
+      super servers
+      @name = name.to_s
+    end
+
+    class << self
+      def new name, args = {}, target = nil, action = :head
+        case target
+        when nil
+          target_id, servers = 1, nil
+        when Group
+          target_id, servers = group.id, target.servers
+        when Node
+          target_id, servers = 1, target.servers
+        else
+          raise TypeError.new("expected #{ target } to kind of Node or nil")
+        end
+
+        synth = super name, servers
+        synth.send '/s_new', synth.name, synth.id, Node::ACTIONS.index(action), target_id, args
+        synth
+      end
+
+      def after target, name, args = {}
+        new name, args, target, :after
+      end
+      
+      def before target, name, args = {}
+        new name, args, target, :before
+      end
+      
+      def head target, name, args = {}
+        new name, args, target, :head
+      end
+      
+      def tail target, name, args = {}
+        new name, args, target, :tail
+      end
+      
+      def replace target, name, args = {}
+        new name, args, target, :replace
+      end
+    end
+
+  end
+end

data/lib/scruby/synthdef.rb

@@ -0,0 +1,109 @@
+module Scruby
+  class SynthDef
+    attr_reader :name, :children, :constants, :control_names
+    # Creates a new SynthDef instance 
+    # An "ugen graph" block should be passed:
+    #
+    #   SynthDef.new('simple') do |rate|
+    #     Out.ar( 0, SinOsc.ar(rate) )
+    #   end
+    #
+    # Default values and rates for the block can be passed with the <tt>:values => []</tt> and <tt>:rates => []</tt> options:
+    # E.g.
+    #   SynthDef.new( :am, :values => [1, 1000, 10, 1] ) do |gate, portadora, moduladora, amp|
+    #     modulacion = SinOsc.kr( moduladora, 0, 0.5, 0.5 )
+    #     sig = SinOsc.ar( portadora, 0, modulacion )
+    #     env = EnvGen.kr( Env.asr(2,1,2), gate, :doneAction => 2 )
+    #     Out.ar( 0, sig*env*amp )
+    #   end
+    #
+    # is equivalent to the Sclang SynthDef
+    #   SynthDef(\am, {|gate=1, portadora=1000, moduladora=10, amp=1|
+    #       var modulacion, sig, env;
+    #       modulacion = SinOsc.kr(moduladora, 0, 0.5, 0.5);
+    #       sig = SinOsc.ar(portadora, 0, modulacion);
+    #       env = EnvGen.kr(Env.asr(2,1,2), gate, doneAction:2);
+    #       Out.ar(0, sig*env*amp);
+    #   }).send(s)
+    #
+    def initialize name, options = {}, &block
+      @name, @children = name.to_s, []
+      raise( ArgumentError.new('An UGen graph (block) must be passed') ) unless block_given?
+
+      values = options.delete( :values ) || []
+      rates  = options.delete( :rates )  || []
+
+      @control_names = collect_control_names block, values, rates
+      build_ugen_graph block, @control_names
+      @constants = collect_constants @children
+
+      @variants  = [] #stub!!!
+    end
+
+    # Returns a string representing the encoded SynthDef in a way scsynth can interpret and generate.
+    # This method is called by a server instance when sending the synthdef via OSC.
+    #
+    # For complex synthdefs the encoded synthdef can vary a little bit from what SClang would generate
+    # but the results will be interpreted in the same way
+    def encode
+      controls         = @control_names.reject { |cn| cn.non_control? }
+      encoded_controls = [controls.size].pack('n') + controls.collect{ |c| c.name.encode + [c.index].pack('n') }.join
+      
+      init_stream + name.encode + constants.encode_floats + values.flatten.encode_floats + encoded_controls +
+      [children.size].pack('n') + children.collect{ |u| u.encode }.join + 
+      [@variants.size].pack('n') #stub!!!
+    end
+
+    def init_stream file_version = 1, number_of_synths = 1 #:nodoc:
+      'SCgf' + [file_version].pack('N') + [number_of_synths].pack('n')
+    end
+
+    def values #:nodoc:
+      @control_names.collect{ |control| control.value }
+    end
+
+    alias :send_msg :send
+    # Sends itself to the given servers. One or more servers or an array of servers can be passed.
+    # If no arguments are given the synthdef gets sent to all instantiated servers
+    # E.g.
+    #   s = Server.new('localhost', 5114)
+    #   s.boot
+    #   r = Server.new('127.1.1.2', 5114)
+    #
+    #   SynthDef.new('sdef'){ Out.ar(0, SinOsc.ar(220)) }.send(s)
+    #   # this synthdef is only sent to s
+    #
+    #   SynthDef.new('sdef2'){ Out.ar(1, SinOsc.ar(222)) }.send
+    #   # this synthdef is sent to both s and r
+    #
+    def send *servers
+      servers.peel!
+      (servers.empty? ? Server.all : servers).each{ |s| s.send_synth_def( self ) } 
+      self
+    end
+
+    private
+    def collect_control_names function, values, rates
+      names = function.arguments
+      names.zip( values, rates ).collect_with_index{ |array, index| ControlName.new *(array << index)  }
+    end
+
+    def build_controls control_names
+      # control_names.select{ |c| c.rate == :noncontrol }.sort_by{ |c| c.control_name.index } + 
+      [:scalar, :trigger, :control].collect do |rate| 
+        same_rate_array = control_names.select{ |control| control.rate == rate }
+        Control.and_proxies_from( same_rate_array ) unless same_rate_array.empty?
+      end.flatten.compact.sort_by{ |proxy| proxy.control_name.index }
+    end
+
+    def build_ugen_graph function, control_names
+      Ugen.synthdef = self
+      function.call *build_controls(control_names)
+      Ugen.synthdef = nil
+    end
+
+    def collect_constants children
+      children.send( :collect_constants ).flatten.compact.uniq
+    end
+  end
+end

data/lib/scruby/ticker.rb

@@ -0,0 +1,92 @@
+module Scruby
+  # Thread.new do
+  #   EventMachine.run do
+  #     EM.set_quantum 5
+  #     EM.error_handler do |e|
+  #       puts e
+  #     end
+  #   end
+  # end
+  
+  # A timer will call a given block periodically. The period is specified in beats per minute.
+  class Ticker
+    attr_reader :start, :tick, :interval
+    attr_accessor :tempo, :resolution, :size, :loop
+    
+    def initialize tempo = 120, size = 16, resolution = 1, loop = true, &block
+      @tempo , @resolution, @size, @loop = tempo , resolution, size, loop
+      @interval   = 60.0 / @tempo
+      @tick       = 0
+      @block      = block
+    end
+    
+    named_args_for :initialize
+    
+    def block &block
+      @block = block
+    end
+
+    def run
+      return self if @timer
+      @start = Time.now
+      @timer = EventMachine::PeriodicTimer.new @interval * 0.01 do
+        if @next.nil? or Time.now >= @next
+          dispatch
+          @tick += @resolution
+          next_time
+        end
+      end
+      self
+    end
+
+    def index
+      return @tick unless @size
+      tick = @tick % @size
+      if tick == 0 and @tick > 0 and !@loop
+        stop
+        nil
+      else
+        tick
+      end
+    end
+
+    def next_time
+      @next = @start + @tick * @interval
+    end
+
+    def stop
+      @timer.cancel if @timer
+      @timer = nil
+      @next  = nil
+      @tick = 0
+      self
+    end
+
+    def running?
+      not @timer.nil?
+    end
+
+    def dispatch
+      @block.call index if @block
+    end
+  end
+
+  class Scheduler < Ticker
+    def initialize opts = {}
+      super
+      @queue = []
+    end
+
+    def dispatch
+      if blocks = @queue[index]
+        blocks.each{ |b| b.call  }
+      end
+    end
+
+    def at tick, &proc
+      @queue[tick] ||= []
+      @queue[tick].push proc
+    end
+  end
+  
+end