maca-Scruby 0.0.8

data/lib/scruby/audio/ugens/ugen_operations.rb

@@ -0,0 +1,44 @@
+module Scruby
+  module Audio
+    module Ugens
+      module UgenOperations
+        operation_indices = YAML::load( File.open( "#{SCRUBY_DIR}/audio/ugens/operation_indices.yaml" ) )
+        UNARY  = operation_indices['unary']
+        BINARY = operation_indices['binary']      
+        OP_SYMBOLS = { :+ => :plus, :- => :minus, :* => :mult, :/ => :div2, :<= => :less_than_or_eql, :>= => :more_than_or_eql }
+        
+        def valid_ugen_input?
+          true
+        end
+        
+        def self.included( klass )
+          klass.send( :include, BinaryOperations )
+          begin; klass.send( :include, UnaryOperators ) if klass.new.ugen?; rescue; end
+        
+          BINARY.each_key do |operator|
+            override = OP_SYMBOLS[operator] || operator #can't name a method ugen_+ so use OP_SYMBOLS hash to get a 'safe' name
+            begin; klass.send :alias_method, "original_#{override}", operator; rescue; end #if there is an original operator method make an alias with the prefix 'original' so it may be called latter
+            klass.send :alias_method, operator, "ugen_#{override}" #alias the newly added operator method with the name of the operator( +, -, mod, etc...)
+          end
+        end
+      
+        module BinaryOperations
+          BINARY.each_key do |op|
+            method_name = OP_SYMBOLS[op] || op #get a 'safe' method name for the method to add
+            eval "def ugen_#{method_name}( input )
+                    return BinaryOpUGen.new(:#{op}, self, input) if input.ugen?
+                    return self.original_#{method_name}( input ) if self.respond_to?( :original_#{method_name} )
+                    raise ArgumentError.new( %(Expected \#\{input\} to be an Ugen) )
+                  end"          
+          end
+        end
+      
+        module UnaryOperators
+          UNARY.each_key do |op|
+            eval "def #{op}; UnaryOpUgen.new(:#{op}, self); end"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scruby/audio/ugens/ugens.rb

@@ -0,0 +1,34 @@
+module Scruby
+  module Audio
+    module Ugens
+      ugen_defs = YAML::load( File.open( "#{SCRUBY_DIR}/audio/ugens/ugen_defs.yaml" ) )
+      puts 'Loading ugen definitions'
+      
+      def self.define_ugen(name, rates)
+        rate_name = {:audio => :ar, :control => :kr, :scalar => :ir, :demand => :new}
+        rates.delete_if{ |key, value| key == :demand  } #I don't know what to do with these
+        
+        methods = rates.collect{ |r| ":#{rate_name[r.first]}" }.join(', ')
+        
+        klass = "class #{name} < Ugen\nclass << self\n" +
+        rates.collect do |r|
+            new_args = ( [r.first] + r.last.collect{|a|a.first} ).join(', ')
+            args = (r.last + [[:mul,1],[:add,0]]).collect{ |a| a.compact.join(' = ')}.join(', ')
+            " def #{rate_name[r.first]}(#{args})\n" +
+            "   new(:#{new_args}).muladd(mul, add)" + 
+            "\n end"
+        end.join("\n") + "\nnamed_args_for #{methods}\nend\nend\n"
+
+        self.class_eval klass
+      end
+      
+      ugen_defs.each_pair do |key, value|
+        self.define_ugen(key, value)
+        print '.'
+        $stdout.flush
+      end
+      puts
+
+    end
+  end
+end

data/lib/scruby/control/metro.rb

@@ -0,0 +1,6 @@
+module Scruby
+  module Control
+    class Metro
+    end
+  end
+end

data/lib/scruby/extensions.rb

@@ -0,0 +1,109 @@
+
+class Object
+  def to_array
+    [*self]
+  end
+
+  def ugen?
+    false
+  end
+
+  def valid_ugen_input?
+    false
+  end
+end
+
+class Numeric
+  def rate
+    :scalar
+  end
+
+  def max( other )
+    self > other ? self : other
+  end
+
+  def min( other )
+    self < other ? self : other
+  end
+end
+
+class Numeric
+  private
+  def collect_constants #:nodoc:
+    self
+  end  
+
+  def input_specs( synthdef )
+    [-1, synthdef.constants.index(self)]
+  end
+end
+
+class Fixnum
+  include Scruby::Audio::Ugens::UgenOperations
+end
+
+class Float
+  include Scruby::Audio::Ugens::UgenOperations
+end
+
+class Array
+  include Scruby::Audio::Ugens::UgenOperations
+
+  #collect with index
+  def collect_with_index
+    indices = (0...self.size).map
+    self.zip( indices ).collect{ |element_with_index| yield( element_with_index.first, element_with_index.last )  }
+  end
+
+  def wrap_to( size )
+    return self if size == self.size
+    self.dup.wrap_to!( size )
+  end
+
+  def wrap_to!( size )
+    return nil if size == self.size
+    original_size = self.size
+    size.times { |i| self[ i ] = self[ i % original_size ] }
+    self
+  end
+
+  def wrap_and_zip( *args )
+    max = args.map{ |a| instance_of?(Array) ? a.size : 0 }.max.max( self.size )
+    args = args.collect{ |a| a.to_array.wrap_to( max ) }
+    self.wrap_to( max ).zip( *args )
+  end
+
+  def to_array
+    self
+  end
+
+  def encode_floats
+    [self.size].pack('n') + self.pack('g*')
+  end
+
+  def muladd( mul, add )
+    self.collect{ |u| MulAdd.new( u, mul, add ) }
+  end
+
+  private
+  def collect_constants #:nodoc:
+    self.collect{ |e| e.send( :collect_constants )  }
+  end
+end
+
+class Proc
+  def argument_names
+    case self.arity
+    when -1..0: []
+    when 1: self.to_sexp.assoc( :dasgn_curr )[1].to_array
+    else self.to_sexp[2][1][1..-1].collect{ |arg| arg[1]  }
+    end
+  end
+end
+
+class String
+  def encode
+    [self.size & 255].pack('C*') + self[0..255]
+  end
+end
+

data/lib/scruby/typed_array.rb

@@ -0,0 +1,64 @@
+class TypedArray < Array
+  
+  attr_reader :type
+  
+  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 :+
+  def +( array )
+    TypedArray.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
+  
+  def flatten
+    self
+  end
+  
+  def compact
+    self
+  end
+  
+  def flatten!
+  end
+
+  def compact!
+  end
+  
+  def check_array_passed(obj)
+    raise TypeError.new( "#{obj} is not Array" ) unless obj.instance_of?(Array)
+  end
+  
+  def check_types_for_array( array ) #:nodoc:
+    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 ) #:nodoc:
+    raise TypeError.new("#{obj} is not instance of #{@type}") unless obj.instance_of?(@type)
+  end
+  
+end

data/spec/audio/env_gen_specs.rb

@@ -0,0 +1,25 @@
+require File.join( File.expand_path(File.dirname(__FILE__)), '..', "helper")
+
+require 'named_arguments'
+require "#{SCRUBY_DIR}/audio/ugens/ugen_operations"
+require "#{SCRUBY_DIR}/audio/ugens/ugen"
+require "#{SCRUBY_DIR}/extensions"
+require "#{SCRUBY_DIR}/audio/env"
+require "#{SCRUBY_DIR}/audio/ugens/env_gen"
+
+include Scruby
+include Audio
+include Ugens 
+
+
+describe EnvGen do
+  
+  it "should have correct inputs" do
+    envgen = EnvGen.kr( Env.adsr )
+    envgen.rate.should == :control
+    envgen.inputs.should == [ 1, 1, 0, 1, 0, 0, 3, 2, -99, 1, 0.01, 5, -4, 0.5, 0.3, 5, -4, 0, 1, 5, -4 ].collect{ |i| i.to_f  }
+  end
+  
+  
+  
+end

data/spec/audio/in_out_spec.rb

@@ -0,0 +1,107 @@
+require File.join( File.expand_path(File.dirname(__FILE__)),"../helper")
+
+require "#{SCRUBY_DIR}/audio/ugens/ugen_operations"
+require "#{SCRUBY_DIR}/extensions"
+require "#{SCRUBY_DIR}/audio/ugens/ugen"
+require "#{SCRUBY_DIR}/audio/ugens/multi_out_ugens"
+require "#{SCRUBY_DIR}/audio/ugens/in_out"
+
+
+require 'named_arguments'
+
+include Scruby
+include Audio
+include Ugens
+
+class SinOsc < Ugen
+  def self.ar( freq=440.0, phase=0.0 ) #not interested in muladd
+    new(:audio, freq, phase)
+  end
+end
+
+describe In do
+  
+  before do
+    @sdef = mock( 'ugen', :children => [] )
+    Ugen.should_receive( :synthdef ).at_least( :once ).and_return( @sdef )
+    
+    @proxy   = mock('output proxy', :valid_ugen_input? => true )
+    @proxies = (1..10).map{ @proxy }
+    OutputProxy.stub!(:new).and_return( @proxy )
+    
+    @ar = In.ar( 3 )
+  end
+  
+  it "respond to #kr and #ar "do
+    In.should respond_to(:kr)
+    In.should respond_to(:ar)
+  end
+  
+  it "should spec #ar" do    
+    @ar.should be_instance_of( Array )
+    @ar.should have(1).proxy
+    @ar.first.should == @proxy
+  end
+  
+  it "should have bus as input" do
+    @sdef.children.first.inputs.should == [3]
+  end
+  
+  it "should have ten channels" do
+    In.ar(0, 10).should == @proxies
+  end
+  
+  it "should describe passing arrays to initialize"
+
+end
+
+
+describe Out do
+  
+  before do
+    @sdef = mock( 'sdef', :children => [], :constants => [400, 0] )
+    Ugen.should_receive( :synthdef ).at_least( :once ).and_return( @sdef )
+    
+  end               
+  
+  it "should accept one ugen" do
+    @ugen1 = Ugen.new( :audio )
+    
+    Out.kr( 1, @ugen1 ).should == 0.0
+    
+    @sdef.children.should have(2).ugens
+    
+    out = @sdef.children.last
+    out.rate.should   == :control
+    out.inputs.should == [1, @ugen1]
+    out.channels.should == []
+  end       
+  
+  it "should accept several inputs" do
+    @ugen1 = Ugen.new( :audio )
+    @ugen2 = Ugen.new( :audio )
+    @ugen3 = Ugen.new( :audio )
+    
+    Out.kr( 1, @ugen1, @ugen2, @ugen3 )
+    @sdef.children.should have(4).ugens
+    
+    out = @sdef.children.last
+    out.inputs.should == [1, @ugen1, @ugen2, @ugen3]
+  end    
+  
+  it "should accept several inputs from array" do
+    @ugen1 = Ugen.new( :audio )
+    @ugen2 = Ugen.new( :audio )
+    @ugen3 = Ugen.new( :audio )
+    
+    Out.kr( 1, [@ugen1, @ugen2, @ugen3] )
+    @sdef.children.should have(4).ugens
+    
+    out = @sdef.children.last
+    out.inputs.should == [1, @ugen1, @ugen2, @ugen3]
+  end
+
+  it "should validate rate"
+  it "should substitute zero with silence"
+  it "should spec passing array on init"
+end

data/spec/audio/integration_spec.rb

@@ -0,0 +1,106 @@
+require File.join( File.expand_path(File.dirname(__FILE__)), '..',"helper")
+require "named_arguments"
+require 'osc'
+
+require "#{SCRUBY_DIR}/audio/ugens/ugen_operations"
+require "#{SCRUBY_DIR}/audio/ugens/ugen"
+require "#{SCRUBY_DIR}/audio/ugens/multi_out_ugens"
+require "#{SCRUBY_DIR}/audio/ugens/in_out"
+
+require "#{SCRUBY_DIR}/audio/ugens/operation_ugens"
+require "#{SCRUBY_DIR}/audio/ugens/ugen"
+
+require "#{SCRUBY_DIR}/audio/ugens/ugens"
+require "#{SCRUBY_DIR}/audio/control_name"
+require "#{SCRUBY_DIR}/audio/synthdef"
+require "#{SCRUBY_DIR}/extensions"
+
+require "#{SCRUBY_DIR}/audio/server"
+
+require "#{SCRUBY_DIR}/audio/env"
+require "#{SCRUBY_DIR}/audio/ugens/env_gen"
+
+include Scruby
+include Audio
+include Ugens
+include OperationUgens
+
+describe "synthdef examples" do
+
+  before :all do
+    @sdef = SynthDef.new(:hola){ |a, b| SinOsc.kr( a ) + SinOsc.kr( b ) } 
+    @expected = [ 83, 67, 103, 102, 0, 0, 0, 1, 0, 1, 4, 104, 111, 108, 97, 0, 1, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 97, 0, 0, 1, 98, 0, 1, 0, 4, 7, 67, 111, 110, 116, 114, 111, 108, 1, 0, 0, 0, 2, 0, 0, 1, 1, 6, 83, 105, 110, 79, 115, 99, 1, 0, 2, 0, 1, 0, 0, 0, 0, 0, 0, -1, -1, 0, 0, 1, 6, 83, 105, 110, 79, 115, 99, 1, 0, 2, 0, 1, 0, 0, 0, 0, 0, 1, -1, -1, 0, 0, 1, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 1, 0, 2, 0, 1, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 1, 0, 0 ].pack('C*')
+  end
+
+  it "should have correct children" do
+    @sdef.children[0].should be_instance_of( Control )
+    @sdef.children[1].should be_instance_of( SinOsc )
+    @sdef.children[2].should be_instance_of( SinOsc )
+    @sdef.children[3].should be_instance_of( BinaryOpUGen )
+  end
+
+  it "should encode with control" do
+    @sdef.encode.should == @expected
+  end
+
+  it "should encode with ops" do
+    expected = [ 83, 67, 103, 102, 0, 0, 0, 1, 0, 1, 4, 104, 101, 108, 112, 0, 2, 67, -36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 2, 0, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 2, 0, 2, 0, 1, 0, 2, 0, 2, 0, 0, 0, 3, 0, 0, 2, 0, 0 ].pack('C*')
+    SynthDef.new(:help){ (SinOsc.ar() + SinOsc.ar()) * SinOsc.ar() }.encode.should == expected
+  end
+
+  it "should encode with out" do
+    sdef = SynthDef.new(:out){ Out.ar(0, SinOsc.ar) }
+    sdef.children.should have(2).children
+    
+    sdef.children[0].should be_instance_of( SinOsc )
+    sdef.children[1].should be_instance_of( Out ) 
+    
+    sdef.constants.should == [ 440, 0 ]
+    sdef.children[1].channels.should == []
+    
+    expected = [ 83, 67, 103, 102, 0, 0, 0, 1, 0, 1, 3, 111, 117, 116, 0, 2, 67, -36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 3, 79, 117, 116, 2, 0, 2, 0, 0, 0, 0, -1, -1, 0, 1, 0, 0, 0, 0, 0, 0 ].pack('C*')
+    sdef.encode.should == expected
+  end
+
+  it "should encode another with out" do
+    sdef = SynthDef.new(:out){ sig = SinOsc.ar(100, 200) * SinOsc.ar(200); Out.ar(0, sig) }
+    sdef.encode.should == [ 83, 67, 103, 102, 0, 0, 0, 1, 0, 1, 3, 111, 117, 116, 0, 3, 66, -56, 0, 0, 67, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 1, -1, -1, 0, 2, 2, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 2, 0, 2, 0, 1, 0, 2, 0, 0, 0, 0, 0, 1, 0, 0, 2, 3, 79, 117, 116, 2, 0, 2, 0, 0, 0, 0, -1, -1, 0, 2, 0, 2, 0, 0, 0, 0 ].pack('C*')
+  end
+  
+  it "should encode out with two channels" do
+    sdef = SynthDef.new( :out ){ sig = SinOsc.ar(100, [200, 200]) * SinOsc.ar(200); Out.ar(0, sig) }
+    expected = [ 83, 67, 103, 102, 0, 0, 0, 1, 0, 1, 3, 111, 117, 116, 0, 3, 66, -56, 0, 0, 67, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 1, -1, -1, 0, 2, 2, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 2, 0, 2, 0, 1, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 2, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 2, 0, 2, 0, 1, 0, 2, 0, 1, 0, 0, 0, 2, 0, 0, 2, 3, 79, 117, 116, 2, 0, 3, 0, 0, 0, 0, -1, -1, 0, 2, 0, 3, 0, 0, 0, 4, 0, 0, 0, 0 ].pack('C*')
+    sdef.encode.should == expected
+  end
+  
+  it "should encode out with multidimensional array" do
+    sdef = SynthDef.new( :out ){ sig = SinOsc.ar(100, [200,[100, 100]]) * SinOsc.ar(200); Out.ar(0, sig) }
+
+    child = sdef.children
+    child[0..3].map { |u| u.should be_instance_of(SinOsc) }
+    child[4].should be_instance_of(BinaryOpUGen)
+    child[5].should be_instance_of(BinaryOpUGen)
+    child[6].should be_instance_of(BinaryOpUGen)
+    child[7].should be_instance_of(Out)
+    child[8].should be_instance_of(Out)
+    #the order of the elements is different than in supercollider, but at least has the encoded string is the same size so i guess its fine
+    sdef.encode.should have(261).chars
+  end
+  
+  it "should encode 'complex' sdef" do
+    sdef = SynthDef.new( :am ) 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);
+    end
+    sdef.children.should have(8).children
+    sdef.constants.should == [0, 0.5, 1, 2, -99, 5, -4]
+    
+    expected = [ 83, 67, 103, 102, 0, 0, 0, 1, 0, 1, 2, 97, 109, 0, 7, 0, 0, 0, 0, 63, 0, 0, 0, 63, -128, 0, 0, 64, 0, 0, 0, -62, -58, 0, 0, 64, -96, 0, 0, -64, -128, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 103, 97, 116, 101, 0, 0, 9, 112, 111, 114, 116, 97, 100, 111, 114, 97, 0, 1, 10, 109, 111, 100, 117, 108, 97, 100, 111, 114, 97, 0, 2, 3, 97, 109, 112, 0, 3, 0, 8, 7, 67, 111, 110, 116, 114, 111, 108, 1, 0, 0, 0, 4, 0, 0, 1, 1, 1, 1, 6, 83, 105, 110, 79, 115, 99, 1, 0, 2, 0, 1, 0, 0, 0, 0, 0, 2, -1, -1, 0, 0, 1, 6, 77, 117, 108, 65, 100, 100, 1, 0, 3, 0, 1, 0, 0, 0, 1, 0, 0, -1, -1, 0, 1, -1, -1, 0, 1, 1, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, 0, 0, 0, 1, -1, -1, 0, 0, 2, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 2, 0, 2, 0, 1, 0, 2, 0, 3, 0, 0, 0, 2, 0, 0, 2, 6, 69, 110, 118, 71, 101, 110, 1, 0, 17, 0, 1, 0, 0, 0, 0, 0, 0, -1, -1, 0, 2, -1, -1, 0, 0, -1, -1, 0, 2, -1, -1, 0, 3, -1, -1, 0, 0, -1, -1, 0, 3, -1, -1, 0, 2, -1, -1, 0, 4, -1, -1, 0, 2, -1, -1, 0, 3, -1, -1, 0, 5, -1, -1, 0, 6, -1, -1, 0, 0, -1, -1, 0, 3, -1, -1, 0, 5, -1, -1, 0, 6, 1, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 2, 0, 2, 0, 1, 0, 2, 0, 4, 0, 0, 0, 5, 0, 0, 2, 3, 79, 117, 116, 2, 0, 2, 0, 0, 0, 0, -1, -1, 0, 0, 0, 6, 0, 0, 0, 0 ].pack('c*')
+    sdef.encode.should == expected
+  end
+
+
+end
+