maca-Scruby 0.0.8

data/lib/scruby/audio/server.rb

@@ -0,0 +1,112 @@
+require 'singleton'
+
+module Scruby 
+  module Audio
+    class UDPSender < OSC::UDPServer #:nodoc:
+      include Singleton
+
+      alias :udp_send :send 
+      def send( command, host, port, *args )
+        udp_send( OSC::Message.new( command, type_tag(args), *args ), 0, host, port )
+      end
+
+      def send_message( message, host, port )
+        udp_send( message, 0, host, port )
+      end
+
+      def type_tag(*args)
+        args = *args
+        args.collect{ |msg| OSC::Packet.tag( msg ) }.to_s
+      end
+    end
+    $UDP_Sender = UDPSender.instance
+    
+    class Server
+      attr_reader :host, :port
+      @@sc_path = '/Applications/SuperCollider/scsynth'
+      @@servers = []
+
+      # 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
+      def initialize( host = 'localhost', port = 57111)
+        @host, @port = host, port
+        @@servers << self
+      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/scsynt (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?( @@sc_path )
+        Thread.new do
+          path = @@sc_path.scan(/[^\/]+/)
+          @server_pipe = IO.popen( "cd /#{ path[0..-2].join('/') }; ./#{ path.last } -u #{ @port }" )
+          loop { p Special.new(@server_pipe.gets.chomp) }
+        end unless @server_pipe        
+      end
+      
+      # Sends the /quit OSC signal to the scsynth server and kills the forked process if the scsynth
+      # server is running locally
+      def stop
+        send '/quit'
+        Process.kill 'KILL', @server_pipe.pid if @server_pipe
+        @server_pipe = nil
+      end
+      
+      # Sends an OSC command to the scsyth server.
+      # E.g. <tt>server.send('/dumpOSC', 1)</tt>
+      def send( command, *args )
+        return $UDP_Sender.send( command, @host, @port, *args )
+      end
+      
+      # Encodes and sends a SynthDef to the scsynth server
+      def send_synth_def( synth_def )
+        *blob = OSC::Blob.new( synth_def.encode ), 0
+        def_message = OSC::Message.new( '/d_recv', $UDP_Sender.type_tag( blob ), *blob )
+        send_message( OSC::Bundle.new( nil, def_message ) )
+      end
+      
+      private
+      def send_message( message ) #:nodoc:
+        $UDP_Sender.send_message( message, @host, @port )
+      end
+      
+      public
+      class << self
+        
+        # Specify the scsynth binary path
+        def sc_path=( path )
+          @@sc_path = path
+        end
+
+        # Get the scsynth path
+        def sc_path
+          @@sc_path
+        end
+      
+        # Returns an array with all the registered servers
+        def all
+          @@servers
+        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
+end

data/lib/scruby/audio/synth.rb

@@ -0,0 +1,15 @@
+module Scruby
+  class Synth < Node
+
+    def initialize( name, opts = {} )
+      super( name, opts.delete(:servers) )
+      @servers.each{ |s| s.send '/s_new', *([@name, self.id, 0, 1] + opts.to_a.flatten) }
+    end
+
+    def set( args = {} )
+      @servers.each{ |s| s.send '/n_set', *([self.id] + args.to_a.flatten) }
+      self
+    end
+
+  end
+end

data/lib/scruby/audio/synthdef.rb

@@ -0,0 +1,114 @@
+module Scruby
+  module Audio
+    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, []
+
+        values = options.delete( :values ) || []
+        rates  = options.delete( :rates )  || []
+        block  = block || Proc.new{}
+
+        @control_names = collect_control_names( block, values, rates )
+        build_ugen_graph( block, @control_names )
+        @constants = collect_constants( @children )
+        
+        @variants = [] #stub!!!
+        
+        warn( 'A SynthDef without a block is useless' ) unless block_given?
+      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') }.to_s
+        
+        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 = *servers
+        (servers ? servers.to_array : Server.all).each{ |s| s.send_synth_def( self ) } 
+        self
+      end
+      
+      private
+      def collect_control_names( function, values, rates ) #:nodoc:
+        return [] if (names = function.argument_names).empty?
+        names.zip( values, rates ).collect_with_index{ |array, index| ControlName.new *(array << index)  }
+      end
+      
+      def build_controls( control_names ) #:nodoc:
+        # 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 ) #:nodoc:
+        Ugen.synthdef = self
+        function.call *build_controls( control_names)
+        Ugen.synthdef = nil
+      end
+      
+      def collect_constants( children ) #:nodoc:
+        children.send( :collect_constants ).flatten.compact.uniq
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Scruby
+  module Audio
+    module Ugens
+      class EnvGen < Ugen
+        class << self
+          def ar( envelope, gate = 1, levelScale = 1, levelBias = 0, timeScale = 1, doneAction = 0 )
+            new(:audio, gate, levelScale, levelBias, timeScale, doneAction, *envelope.to_array)
+          end
+
+          def kr( envelope, gate = 1, levelScale = 1, levelBias = 0, timeScale = 1, doneAction = 0 )
+            new(:control, gate, levelScale, levelBias, timeScale, doneAction, *envelope.to_array)
+          end
+          named_args_for :ar, :kr
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Scruby
+  module Audio
+    module Ugens
+
+      class In < MultiOutUgen
+        def initialize( rate, channels, bus ) #:nodoc:
+          super rate, *(0...channels).map{ |i| OutputProxy.new rate, self, i }
+          @inputs = [bus]
+        end
+        
+        def self.ar( bus, channels = 1 )
+          new :audio, channels, bus
+        end
+        
+        def self.kr( bus, num_channels = 1 )
+          new :control, channels, bus
+        end
+      end
+
+      class Out < Ugen
+        def initialize(*args) #:nodoc:
+          super
+          @channels = []
+        end
+
+        def self.ar (  bus, *inputs )
+          inputs = *inputs
+          new :audio, bus, *inputs; 0.0    #Out has no output
+        end
+
+        def self.kr (  bus, *inputs )
+          inputs = *inputs
+          new :control, bus, *inputs; 0.0  #Out has no output
+        end
+
+        def output_specs
+          []
+        end
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Scruby
+  module Audio
+    module Ugens 
+
+      class OutputProxy < Ugen
+        attr_reader :source, :control_name, :output_index
+        
+        def initialize( rate, source, output_index, name = nil )
+          super rate
+          @source, @control_name, @output_index = source, name, output_index
+        end
+        
+        def index 
+          @source.index
+        end
+        
+        def add_to_synthdef; end
+      end
+      
+      class MultiOutUgen < Ugen
+        def initialize( rate, *channels )
+          super rate
+          @channels = channels
+        end
+        
+        def self.new( rate, *args )
+          super( rate, *args ).channels #returns the channels but gets instantiated
+        end
+        
+        private     
+        def output_specs
+          channels.collect{ |output| output.send :output_specs }.flatten
+        end
+      end
+
+      class Control < MultiOutUgen #:nodoc:
+        def initialize( rate, *names )
+          super rate, *names.collect_with_index{|n, i| OutputProxy.new rate, self, i, n }
+        end
+        
+        def self.and_proxies_from( names )
+          Control.new( names.first.rate, *names )
+        end
+      end
+      
+    end
+  end
+end

data/lib/scruby/audio/ugens/operation_indices.yaml

@@ -0,0 +1,92 @@
+
+binary:
+  !ruby/symbol +:                  0
+  !ruby/symbol -:                  1
+  !ruby/symbol *:                  2
+  !ruby/symbol div:                3
+  !ruby/symbol /:                  4
+  !ruby/symbol mod:                5
+  !ruby/symbol <=:                 10
+  !ruby/symbol >=:                 11
+  !ruby/symbol minimum:            12
+  !ruby/symbol maximum:            13 #can't be called max because there is an array method calle maximum
+  !ruby/symbol lcm:                17
+  !ruby/symbol gcd:                18
+  !ruby/symbol round:              19
+  !ruby/symbol roundUp:            20
+  !ruby/symbol trunc:              21
+  !ruby/symbol atan2:              22
+  !ruby/symbol hypot:              23
+  !ruby/symbol hypotApx:           24
+  !ruby/symbol pow:                25
+  !ruby/symbol leftShift:          26
+  !ruby/symbol rightShift:         27
+  !ruby/symbol unsignedRightShift: 28
+  !ruby/symbol ring1:              30
+  !ruby/symbol ring2:              31
+  !ruby/symbol ring3:              32
+  !ruby/symbol ring4:              33
+  !ruby/symbol difsqr:             34
+  !ruby/symbol sumsqr:             35
+  !ruby/symbol sqrsum:             36
+  !ruby/symbol sqrdif:             37
+  !ruby/symbol absdif:             38
+  !ruby/symbol thresh:             39
+  !ruby/symbol amclip:             40
+  !ruby/symbol scaleneg:           41
+  !ruby/symbol clip2:              42
+  !ruby/symbol excess:             43
+  !ruby/symbol fold2:              44
+  !ruby/symbol wrap2:              45
+  !ruby/symbol rrand:              47
+  !ruby/symbol exprand:            48
+ 
+unary:
+  !ruby/symbol neg:                0
+  !ruby/symbol bitNot:             4
+  !ruby/symbol abs:                5
+  !ruby/symbol asFloat:            6
+  !ruby/symbol ceil:               8
+  !ruby/symbol floor:              9
+  !ruby/symbol frac:               10
+  !ruby/symbol sign:               11
+  !ruby/symbol squared:            12
+  !ruby/symbol cubed:              13
+  !ruby/symbol sqrt:               14
+  !ruby/symbol exp:                15
+  !ruby/symbol reciprocal:         16
+  !ruby/symbol midicps:            17
+  !ruby/symbol cpsmidi:            18
+  !ruby/symbol midiratio:          19
+  !ruby/symbol ratiomidi:          20
+  !ruby/symbol dbamp:              21
+  !ruby/symbol ampdb:              22
+  !ruby/symbol octcps:             23
+  !ruby/symbol cpsoct:             24
+  !ruby/symbol log:                25
+  !ruby/symbol log2:               26
+  !ruby/symbol log10:              27
+  !ruby/symbol sin:                28
+  !ruby/symbol cos:                29
+  !ruby/symbol tam:                30
+  !ruby/symbol asin:               31
+  !ruby/symbol acos:               32
+  !ruby/symbol atan:               33
+  !ruby/symbol sinh:               34
+  !ruby/symbol cosh:               35
+  !ruby/symbol tanh:               36
+  !ruby/symbol rand:               37
+  !ruby/symbol rand2:              38
+  !ruby/symbol linrand:            39
+  !ruby/symbol bilinrand:          40
+  !ruby/symbol sum3rand:           41
+  !ruby/symbol distort:            42
+  !ruby/symbol softclip:           43
+  !ruby/symbol coin:               44
+  !ruby/symbol rectWindow:         48
+  !ruby/symbol hanWindow:          49
+  !ruby/symbol welWindow:          50
+  !ruby/symbol triWindow:          51
+  !ruby/symbol ramp:               52
+  !ruby/symbol scurve:             53
+