live_api 0.9.0

data/Manifest

@@ -0,0 +1,3 @@
+Rakefile
+lib/live_api.rb
+Manifest

data/Rakefile

@@ -0,0 +1,13 @@
+
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('live_api', '0.9.0') do |p|
+  p.description = 'This module allows you to create a connection to Ableton Live 8.1.x through a Max4Live plugin. You can then manipulate objects in the LOM (Live Object Model) as though they were Ruby objects.'
+  p.url = 'http://irkenkitties.com'
+  p.author = 'Saf Allen'
+  p.email = 'irkenkitties @nospam@ gmail.com'
+  p.ignore_pattern = ['build.sh']
+  p.development_dependencies = ['rosc']
+end

data/lib/live_api.rb

@@ -0,0 +1,251 @@
+###################################################################################
+#  This module allows you to create a connection to Ableton Live 8.1.x through a
+#  Max4Live plugin. You can then manipulate objects in the LOM (Live Object Model)
+#  as though they were Ruby objects.
+#  
+#  Author: Saf Allen
+###################################################################################
+require 'rubygems'
+require 'osc'
+
+
+###  Extend the StringIO to have a skip method
+class StringIO
+
+  ###  Skip n bytes
+  def skip(n)
+    self.seek(n, IO::SEEK_CUR)
+  end
+
+
+  ###  Skip the OSC 4 byte alinged padding
+  def skip_padding
+    self.skip((4-pos)%4)
+  end
+end
+
+
+module LiveAPI
+
+  ###  A class to manage a UDP Open Sound Control connection 
+  ###  to Ableton Live
+  class LiveConnection
+
+    TypeTags = {'i' => :decode_int32, 'f' => :decode_float32, 'b' => :decode_blob, 's' => :decode_string}
+    ClassMap = {Fixnum => 'i', Float => 'f', String => 's'}
+
+    public
+    ###  Initialize
+    def initialize(host, port)
+     @host = host
+     @server_port = port.succ
+     @client_port = port
+     @client = OSC::UDPSocket.new
+     @server = OSC::UDPServer.new
+     @server.bind(nil, @server_port)
+    end
+
+
+    ###  Send an OSC message
+    def request(path, *cmds)
+      type_tags = cmds.map{|cmd| ClassMap[cmd.class]}.join
+      message = OSC::Message.new(path, type_tags, *cmds)
+      @client.send(message, 0, 'localhost', 9000)
+      cmds.last == 'getinfo' ? receive_multi : receive unless(cmds.first == 'set')
+    end
+
+
+    private
+    ###  Send a message
+    def send_message(message)
+      @client.send(message, 0, @host, @client_port)
+    end
+
+
+    ###  Receive a single message
+    def receive
+      response, sender = @server.recvfrom(32_767)
+      [decode_osc(response)]
+    end
+
+
+    ###  Receive a message with multiple parts
+    def receive_multi
+      response_ary = []
+      while 1
+	response, sender = @server.recvfrom(32_767)
+	response = decode_osc(response)
+	response_ary << response
+	break if response[1] == 'done'
+      end
+      return response_ary
+    end
+
+
+    ###  Decode and OSC packet
+    def decode_osc(message)
+      parsed = []
+      io = StringIO.new(message)
+      parsed << decode_string(io)
+      type_tags = decode_string(io)
+      type_tags = type_tags.split(//)
+      type_tags.shift
+      type_tags.each do |type_tag|
+	parsed << self.send(TypeTags[type_tag], io) rescue nil
+      end
+      parsed
+    end
+
+
+    ###  Decode a 32 bit int
+    def decode_int32(io)
+      i = io.read(4).unpack('N')[0]
+      i = 2**32 - i if i > (2**31-1) # two's complement
+      i
+    end
+
+
+    ###  Decode a 32 bit float
+    def decode_float32(io)
+      f = io.read(4).unpack('g')[0]
+      f
+    end
+
+
+    ###  Decode a string
+    def decode_string(io)
+      s = io.gets("\0").chomp("\0")
+      io.skip_padding
+      s
+    end
+
+
+    ###  Decode a blob of data
+    def decode_blob(io)
+      l = io.read(4).unpack('N')[0]
+      b = io.read(l)
+      io.skip_padding
+      b
+    end
+
+
+    ###  Decode a time tag
+    def decode_timetag(io)
+      t1 = io.read(4).unpack('N')[0]
+      t2 = io.read(4).unpack('N')[0]
+      [t1,t2]
+    end
+  end
+
+
+  ###  LiveObject is a base class for any type of object in Ableton Live
+  class LiveObject
+   
+    attr_reader :properties, :functions, :id, :live_path, :type, :children, :live_connection
+
+    ###  Thanks _why
+    def metaclass; class << self; self; end; end
+    def meta_eval &blk; metaclass.instance_eval &blk; end
+
+
+    ###  A nicer inspect method
+    def inspect
+      "<#{@type} id: #{@id} #{name.first if self.respond_to?(:name)}>"
+    end
+
+
+    ###  Initialize
+    def initialize(live_path, live_connection)
+      @live_path = live_path
+      @live_connection = live_connection
+      setup_object(live_connection.request(live_path, 'getinfo'))
+    end
+
+
+    ###  Parse Live's getinfo data to set up this object
+    def setup_object(info_list)
+      @properties = []
+      @functions = []
+      @children = []
+      info_list.each do |info|
+	info.shift
+	case info.first
+	  when 'id'
+	    @id = info.last
+	  when 'type'
+	    @type = info.last
+	  when 'description'
+	    info.shift
+	    @description = info.join(' ').gsub('\\', ',')
+	  when 'children'
+	    info.shift
+	    @children << info[0]
+	    metaclass.class_eval do
+	      define_method(info[0].to_sym) do 
+		children = []
+                child_count = getcount(info[0].to_sym)
+		0.upto(child_count - 1) do |i|
+		  child = LiveObject.new("#{@live_path}/#{info.first}/#{i}", @live_connection)
+		  children << child
+		end
+		return children
+	      end
+	    end
+	  when 'child'
+	    info.shift
+	    @children << info[0]
+	    metaclass.class_eval do
+	      define_method(info[0].to_sym) do
+		return LiveObject.new("#{@live_path}/#{info.first}", @live_connection)
+	      end
+	    end
+	  when 'property'
+	    @properties << info[1]
+	    ###  Setup property get
+	    metaclass.class_eval do
+	      define_method(info[1].to_sym) do
+		response = @live_connection.request(@live_path, 'get', info[1]).first
+                #  This may be wrong if a request ever returns more than a 2 element array [key,val]
+		return response.last
+	      end
+	    end
+
+	    ###  Setup property set
+	    metaclass.class_eval do
+	      define_method((info[1] + '=').to_sym) do |arg|
+		@live_connection.request(@live_path, 'set', info[1], arg)
+	      end
+	    end
+	  when 'function'
+	    @functions << info[1]
+	    metaclass.class_eval do
+	      define_method(info[1].to_sym) do 
+		@live_connection.request(@live_path, 'call', info[1])
+	      end
+	    end
+	end
+      end
+
+      ###  Add method for counting children
+      metaclass.class_eval do
+	define_method(:getcount) do |child|
+	  child = child.to_s
+	  return 0 unless @children.include?(child) and child.match(/s$/)
+	  count = @live_connection.request(@live_path, 'getcount', child)
+	  count.last.last
+	end
+      end
+    end
+
+  end
+
+
+  ###  Quickly make a connection on the default port
+  ###  and return the live_set root object
+  def connect_default
+    lc = LiveConnection.new('localhost', 9000)
+    LiveObject.new('/live_set', lc)
+  end
+  module_function :connect_default
+
+end

data/live_api.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{live_api}
+  s.version = "0.9.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Saf Allen"]
+  s.date = %q{2010-10-14}
+  s.description = %q{This module allows you to create a connection to Ableton Live 8.1.x through a Max4Live plugin. You can then manipulate objects in the LOM (Live Object Model) as though they were Ruby objects.}
+  s.email = %q{irkenkitties @nospam@ gmail.com}
+  s.extra_rdoc_files = ["lib/live_api.rb"]
+  s.files = ["Rakefile", "lib/live_api.rb", "Manifest", "live_api.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{http://irkenkitties.com}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Live_api"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{live_api}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{This module allows you to create a connection to Ableton Live 8.1.x through a Max4Live plugin. You can then manipulate objects in the LOM (Live Object Model) as though they were Ruby objects.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rosc>, [">= 0"])
+    else
+      s.add_dependency(%q<rosc>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rosc>, [">= 0"])
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: live_api
+version: !ruby/object:Gem::Version 
+  version: 0.9.0
+platform: ruby
+authors: 
+- Saf Allen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-14 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rosc
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: This module allows you to create a connection to Ableton Live 8.1.x through a Max4Live plugin. You can then manipulate objects in the LOM (Live Object Model) as though they were Ruby objects.
+email: irkenkitties @nospam@ gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- lib/live_api.rb
+files: 
+- Rakefile
+- lib/live_api.rb
+- Manifest
+- live_api.gemspec
+has_rdoc: true
+homepage: http://irkenkitties.com
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Live_api
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: live_api
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: This module allows you to create a connection to Ableton Live 8.1.x through a Max4Live plugin. You can then manipulate objects in the LOM (Live Object Model) as though they were Ruby objects.
+test_files: []
+