osc-ruby 0.2.0

data/lib/osc-ruby/network_packet.rb

@@ -0,0 +1,42 @@
+module OSC
+  class NetworkPacket
+    def initialize(str)       
+      @str, @index = str, 0 
+    end
+    
+    def to_s
+      @str
+    end
+    
+    def rem() 
+      @str.length - @index 
+    end
+    
+    def eof? () 
+      rem <= 0 
+    end
+    
+    def skip(n) 
+      @index += n 
+    end
+    
+    def skip_padding() 
+      skip((4 - (@index % 4)) % 4) 
+    end
+ 
+    def getn(n)
+    	raise EOFError if rem < n
+    	s = @str[@index, n]
+    	skip(n)
+    	s
+    end
+
+    def getc
+    	raise EOFError if rem < 1
+    	c = @str[@index]
+    	skip(1)
+    	c
+    end
+    
+  end
+end

data/lib/osc-ruby/osc_argument.rb

@@ -0,0 +1,18 @@
+module OSC
+  class OSCArgument
+
+    def initialize(val) @val = val end
+
+    attr_accessor :val
+
+    def to_i() @val.to_i end
+    def to_f() @val.to_f end
+    def to_s() @val.to_s end
+
+
+  private
+    def padding(s)
+      s + ("\000" * ((4 - (s.size % 4)) % 4))
+    end
+  end
+end

data/lib/osc-ruby/osc_packet.rb

@@ -0,0 +1,118 @@
+require File.join( File.dirname( __FILE__ ), 'network_packet')
+require 'ostruct'
+
+module OSC
+  class OSCPacket
+        
+    def self.messages_from_network( string )
+      messages = []
+      osc = new( string )
+      
+      if osc.bundle?
+        bundle = osc.get_string
+        time = osc.get_timestamp
+        
+        osc.get_bundle_messages.each do | message |
+          messages << decode_simple_message( time, OSCPacket.new( message ) )
+        end
+        
+      else
+        messages << decode_simple_message( time, osc )
+      end
+      
+      return messages
+    end
+    
+    def self.decode_simple_message( time, osc_packet )
+      address = osc_packet.get_string
+      args = osc_packet.get_arguments 
+
+      Message.new_with_time(address, time, nil, *args )
+    end
+    
+    def initialize( string )
+      @packet = NetworkPacket.new( string )
+      
+      @types = { "i" => lambda{  OSCInt32.new(   get_int32 ) }, 
+                 "f" => lambda{  OSCFloat32.new( get_float32 ) },
+                 "s" => lambda{  OSCString.new(  get_string ) },
+                 "b" => lambda{  OSCBlob.new(    get_blob )}
+                }
+    end
+    
+    def get_bundle_messages
+      bundle_messages = []
+      
+      until @packet.eof?
+        l = @packet.getn(4).unpack('N')[0]
+        bundle_messages << @packet.getn(l)
+      end
+      bundle_messages
+    end
+    
+    def get_string
+      result = ''
+      until (c = @packet.getc) == string_delemeter
+	      result << c
+      end
+      @packet.skip_padding
+      result
+    end
+    
+    def get_timestamp
+      t1 = @packet.getn(4).unpack('N')[0]
+      t2 = @packet.getn(4).unpack('N')[0]
+      @packet.skip_padding
+      
+      if t1 == 0 && t2 == 1
+        time = nil
+      else
+        time = t1 + t2.to_f / (2**32)
+      end
+      
+      time
+    end
+    
+    def get_arguments
+      if @packet.getc == ?,
+        
+        tags = get_string
+        args = []
+        
+        tags.scan(/./) do | tag |
+          args << @types[tag].call
+        end
+        args
+      end
+    end
+    
+    def get_int32
+      i = @packet.getn(4).unpack('N')[0]
+      i -= 2**32 if i > (2**31-1)
+      @packet.skip_padding
+      i
+    end
+    
+    def get_float32
+      f = @packet.getn(4).unpack('g')[0]
+      @packet.skip_padding
+      f
+    end
+    
+    def get_blob
+      l = @packet.getn(4).unpack('N')[0]
+      b = @packet.getn(l)
+      @packet.skip_padding
+      b
+    end
+    
+    def bundle?
+      !(@packet.to_s =~ /\A\#bundle/).nil?
+    end
+    
+    def string_delemeter
+      # ruby 1.9 has multicharacter support
+      RUBY_VERSION.include?( '1.9' ) ? "\x00" : 0
+    end
+  end
+end

data/lib/osc-ruby/osc_types.rb

@@ -0,0 +1,31 @@
+require File.join( File.dirname( __FILE__ ), "osc_argument" )
+
+ module OSC
+  class OSCInt32 < OSCArgument
+
+    def tag() 'i' end
+    def encode() [@val].pack('N') end
+
+  end
+
+  class OSCFloat32 < OSCArgument
+
+    def tag() 'f' end
+    def encode() [@val].pack('g') end # fake - why fake?
+
+  end
+
+  class OSCString < OSCArgument
+
+    def tag() 's' end
+    def encode() padding(@val.sub(/\000.*\z/, '') + "\000") end
+
+  end
+
+  class OSCBlob < OSCArgument
+
+    def tag() 'b' end
+    def encode() padding([@val.size].pack('N') + @val) end
+
+  end
+end

data/lib/osc-ruby/packet.rb

@@ -0,0 +1,134 @@
+module OSC
+  class Packet
+
+    class PO
+      def initialize(str) 
+        @str, @index = str, 0 
+      end
+      
+      def rem() 
+        @str.length - @index 
+      end
+      
+      def eof? () 
+        rem <= 0 
+      end
+      
+      def skip(n) 
+        @index += n 
+      end
+      
+      def skip_padding() 
+        skip((4 - (@index % 4)) % 4) 
+      end
+
+      def getn(n)
+      	raise EOFError if rem < n
+      	s = @str[@index, n]
+      	skip(n)
+      	s
+      end
+
+      def getc
+      	raise EOFError if rem < 1
+      	c = @str[@index]
+      	skip(1)
+      	c
+      end
+    end
+
+    def self.decode_int32(io)
+      i = io.getn(4).unpack('N')[0]
+      i -= 2**32 if i > (2**31-1)
+      i
+    end
+
+    def self.decode_float32(io)
+      f = io.getn(4).unpack('g')[0]
+      f
+    end
+
+    def self.decode_string(io)
+      s = ''
+      until (c = io.getc) == 0
+	      s << c
+      end
+      io.skip_padding
+      s
+    end
+
+    def self.decode_blob(io)
+      l = io.getn(4).unpack('N')[0]
+      b = io.getn(l)
+      io.skip_padding
+      b
+    end
+
+    def self.decode_timetag(io)
+      t1 = io.getn(4).unpack('N')[0]
+      t2 = io.getn(4).unpack('N')[0]
+      [t1, t2]
+    end
+
+    def self.decode2(time, packet, list)
+      io = PO.new(packet)
+      id = decode_string(io)
+      if id =~ /\A\#/
+	      if id == '#bundle'
+	        t1, t2 = decode_timetag(io)
+	        if t1 == 0 && t2 == 1
+	          time = nil
+	        else
+	          time = t1 + t2.to_f / (2**32)
+	        end
+	        until io.eof?
+	          l = io.getn(4).unpack('N')[0]
+	          s = io.getn(l)
+	          decode2(time, s, list)
+	        end
+	      end
+      elsif id =~ /\//
+        address = id
+        if io.getc == ?,
+          tags = decode_string(io)
+          args = []
+          tags.scan(/./) do |t|
+            case t
+             when 'i'
+               i = decode_int32(io)
+               args << OSCInt32.new(i)
+             when 'f'
+               f = decode_float32(io)
+               args << OSCFloat32.new(f)
+             when 's'
+               s = decode_string(io)
+               args << OSCString.new(s)
+             when 'b'
+               b = decode_blob(io)
+               args << OSCBlob.new(b)
+             when /[htd]/; io.read(8)
+             when 'S'; decode_string(io)
+             when /[crm]/; io.read(4)
+             when /[TFNI\[\]]/;
+            end
+	        end
+	        list << [time, Message.new(address, nil, *args)]
+        end
+      end
+    end
+    
+    private_class_method  :decode_int32, 
+                          :decode_float32, 
+                          :decode_string, 
+                          :decode_blob, 
+                          :decode_timetag, 
+                          :decode2
+
+    def self.decode(packet)
+      list = []
+      decode2(nil, packet, list)
+      list
+    end
+
+  end
+end

data/lib/osc-ruby/server.rb

@@ -0,0 +1,91 @@
+module OSC
+  class  Server
+
+    def initialize(port)
+      @socket = UDPSocket.new
+      @socket.bind('', port)
+      @cb = []
+      @queue = Queue.new
+    end
+    
+    def run
+      start_dispatcher
+      
+      start_detector
+    end
+    
+    def stop
+      @socket.close
+    end
+
+    def add_method(address_pattern, &proc)
+      matcher = AddressPattern.new( address_pattern )
+      
+      @cb << [matcher, proc]
+    end
+
+private
+
+    def start_detector
+      begin
+	      detector
+      rescue
+	      Thread.main.raise $!
+      end
+    end
+  
+    def start_dispatcher
+      Thread.fork do
+	      begin
+	        dispatcher
+	      rescue
+	        Thread.main.raise $!
+	      end
+      end
+    end
+
+    def sendmesg(mesg)
+      @cb.each do |matcher, obj|
+	      if matcher.match?( mesg.address )
+	        obj.call( mesg )
+	      end
+      end
+    end
+
+    def dispatcher
+      loop do
+	      mesg = @queue.pop
+        dispatch_message( mesg )
+      end
+    end
+
+    def detector
+      loop do
+	      pa, network = @socket.recvfrom(16384)
+	      begin
+	        
+	        OSCPacket.messages_from_network(pa).each do |x| 
+	          @queue.push(x)
+          end
+          
+	      rescue EOFError
+	      end
+      end
+    end
+    
+    def dispatch_message( message )
+      diff = ( message.time || 0 ) - Time.now.to_ntp
+      
+      if diff <= 0
+        sendmesg( message)
+      else # spawn a thread to wait until it's time
+        Thread.fork do
+    	    sleep(diff)
+    	    sendmesg(mesg)
+    	    Thread.exit
+    	  end
+      end
+    end
+
+  end
+end

data/spec/builders/message_builder.rb

@@ -0,0 +1,51 @@
+class MessageBuilder
+  
+  def initialize
+    @address = ""
+    @tags = []
+    @values = []
+    @time = nil
+  end
+  
+  def with_address( addr )
+    @address = addr
+    self
+  end
+  
+  def with_float( float )
+    with_arg( "f", float )
+    self
+  end
+  
+  def with_int( int )
+    with_arg( "i", int )
+    self
+  end
+  
+  def with_string( string )
+    with_arg( "s", string )
+    self
+  end
+  
+  def with_blob( blob )
+    with_arg( "b", blob )
+    self
+  end
+  
+  def with_time( time )
+    @time = time
+  end
+  
+  def build
+    message = OSC::Message.new( @address , *@values)
+    message.time = @time
+    message
+  end
+  
+private
+
+  def with_arg( tag, value )
+    @tags << tag 
+    @values << value 
+  end
+end