zgomot 0.1.3 → 1.0.0

data/lib/zgomot/drivers/core_midi.rb

@@ -1,148 +1,185 @@
-##############################################################################################################
 class Zgomot::Drivers
 
-  #####-------------------------------------------------------------------------------------------------------
   class CoreMidi < Driver
 
-    #-------------------------------------------------------------------------------------------------------
-    attr_reader :input
+    attr_reader :destinations, :sources, :input, :output
 
-    #---------------------------------------------------------------------------------------------------------
+    # API Wrapper
     module Interface
 
-      #-------------------------------------------------------------------------------------------------------
       extend FFI::Library
       ffi_lib '/System/Library/Frameworks/CoreMIDI.framework/Versions/Current/CoreMIDI'
 
-      ####...................................
       typedef :pointer, :CFStringRef
       typedef :int32,   :ItemCount
       typedef :pointer, :MIDIClientRef
       typedef :pointer, :MIDIDeviceRef
       typedef :pointer, :MIDIEntityRef
       typedef :pointer, :MIDIObjectRef
+      typedef :pointer, :MIDIEndpointRef
+      typedef :uint32,  :MIDITimeStamp
+      typedef :pointer, :MIDIPortRef
       typedef :int32,   :OSStatus
 
-      ####...................................
-      attach_function :MIDIClientCreate, [:pointer, :pointer, :pointer, :pointer], :int
-      attach_function :MIDIClientDispose, [:pointer], :int
+      class MIDIPacket < FFI::Struct
+        layout :timestamp,  :MIDITimeStamp,
+               :nothing,    :uint32,
+               :length,     :uint16,
+               :data,       [:uint8, 256]
+      end
+
+      class MIDIPacketList < FFI::Struct
+        layout :numPackets,   :uint32,
+               :packet,       [MIDIPacket.by_value, 1]
+      end
+
+      callback :MIDIReadProc, [MIDIPacketList.by_ref, :pointer, :pointer], :pointer
+
+      attach_function :MIDIClientCreate, [:pointer, :pointer, :pointer, :pointer], :OSStatus
+      attach_function :MIDIGetNumberOfDevices, [], :ItemCount
+      attach_function :MIDIGetNumberOfDestinations, [], :ItemCount
+      attach_function :MIDIGetNumberOfSources, [], :ItemCount
+      attach_function :MIDIClientDispose, [:MIDIClientRef], :OSStatus
       attach_function :MIDIDeviceGetEntity, [:MIDIDeviceRef, :ItemCount], :MIDIEntityRef
-      attach_function :MIDIGetDestination, [:int], :pointer
+      attach_function :MIDIGetDestination, [:ItemCount], :MIDIEndpointRef
+      attach_function :MIDIGetSource, [:ItemCount], :MIDIEndpointRef
       attach_function :MIDIGetDevice, [:ItemCount], :MIDIDeviceRef
-      attach_function :MIDIOutputPortCreate, [:MIDIClientRef, :CFStringRef, :pointer], :int
-      attach_function :MIDIObjectGetStringProperty, [:MIDIObjectRef, :CFStringRef, :pointer], :OSStatus
-      attach_function :MIDIPacketListInit, [:pointer], :pointer
+      attach_function :MIDIOutputPortCreate, [:MIDIClientRef, :CFStringRef, :MIDIPortRef], :OSStatus
+      attach_function :MIDIInputPortCreate, [:MIDIClientRef, :CFStringRef, :MIDIReadProc, :pointer, :MIDIPortRef], :OSStatus
+      attach_function :MIDIObjectGetStringProperty, [:MIDIObjectRef, :CFStringRef, :CFStringRef], :OSStatus
+      attach_function :MIDIPacketListInit, [:pointer], MIDIPacket.by_ref
       attach_function :MIDIPacketListAdd, [:pointer, :int, :pointer, :int, :int, :pointer], :pointer
-      attach_function :MIDISend, [:pointer, :pointer, :pointer], :int
- 
-      #-------------------------------------------------------------------------------------------------------
-      module CFString
+      attach_function :MIDISend, [:MIDIPortRef, :MIDIEndpointRef, :pointer], :OSStatus
+      attach_function :MIDIReceived, [:MIDIEndpointRef, :pointer], :OSStatus
+      attach_function :MIDIPortConnectSource, [:MIDIPortRef, :MIDIEndpointRef, :pointer], :OSStatus
+      attach_function :MIDIPortDisconnectSource, [:MIDIPortRef, :MIDIEndpointRef], :OSStatus
 
-        ####...................................
+      module CFString
         extend FFI::Library
         ffi_lib '/System/Library/Frameworks/CoreFoundation.framework/Versions/Current/CoreFoundation'
-
-        ####...................................
         attach_function :CFStringCreateWithCString, [:pointer, :string, :int], :pointer
         attach_function :CFStringGetCStringPtr, [:pointer, :int], :pointer
-
-      #### CFString
       end
 
-    #### Interface
     end
 
-    #---------------------------------------------------------------------------------------------------------
-    # instance methods
-    #---------------------------------------------------------------------------------------------------------
+    # Driver
     def initialize
-      find_iac_device
-      get_entity
-      create_client
-      connect_endpoint
-      get_destination
+      load_destinations
+      load_sources
+      find_iac_destination
+      @input_client = create_client('Input-Client')
+      @output_client = create_client('Output-Client')
+      create_output_port
+      create_input_port
     end
 
-    #---------------------------------------------------------------------------------------------------------
-    # Driver API
-    #---------------------------------------------------------------------------------------------------------
     def close
       Map.MIDIClientDispose(@client)
     end
 
-    #---------------------------------------------------------------------------------------------------------
     def write(*data)
-
-      ####...................................
       size = data.size
       format = "C" * size
-      bytes = (FFI::MemoryPointer.new FFI.type_size(:char) * size)
+      bytes = FFI::MemoryPointer.new(FFI.type_size(:char) * size)
       bytes.write_string(data.pack(format))
-      
-      ####...................................
       packet_list = FFI::MemoryPointer.new(256)
       packet_ptr = Interface.MIDIPacketListInit(packet_list)
-
-      ####...................................
       packet_ptr = Interface.MIDIPacketListAdd(packet_list, 256, packet_ptr, 0, size, bytes)
+      Interface.MIDISend(@output_port, @destination, packet_list)
+    end
 
-      ####...................................
-      Interface.MIDISend(@endpoint, @destination, packet_list)
+    def add_input(name)
+      remove_input(name) if @input
+      src_index = find_source_index_for_name(name)
+      src = Interface.MIDIGetSource(src_index)
+      Interface::MIDIPortConnectSource(@input_port, src, nil)
+      @input = name
+    end
 
+    def remove_input(name)
+      src_index = find_source_index_for_name(name)
+      src = Interface.MIDIGetSource(src_index)
+      Interface::MIDIPortDisconnectSource(@input_endpoint, src)
+      @input = nil
     end
 
-    #---------------------------------------------------------------------------------------------------------
-    # Utils
-    #---------------------------------------------------------------------------------------------------------
-    def find_iac_device
-      i, entity_counter, @device = 0, 0, nil
-      while !(device_pointer = Interface.MIDIGetDevice(i)).null?
-        device_model = get_property(:model, device_pointer)
-        if device_model.eql?('IAC Driver')
-          @device = device_pointer
-          break
-        end
+    private
+
+      def load_destinations
+        @destinations = (0..(Interface.MIDIGetNumberOfDestinations()-1)).reduce([]) do |dest, i|
+                          destination_ptr = Interface.MIDIGetDestination(i)
+                          dest << get_property(:model, destination_ptr)
+                        end
       end
-      raise(Zgomot::Error, "IAC Driver not found") unless @device
-    end
 
-    #---------------------------------------------------------------------------------------------------------
-    def get_entity
-      @entity = Interface.MIDIDeviceGetEntity(@device, 0)
-      raise(Zgomot::Error, "Driver initialization failed") unless @entity
-    end
-    
-    #---------------------------------------------------------------------------------------------------------
-    def get_property(name, from = @device)
-      prop = Interface::CFString.CFStringCreateWithCString(nil, name.to_s, 0)
-      val = Interface::CFString.CFStringCreateWithCString(nil, name.to_s, 0)
-      Interface::MIDIObjectGetStringProperty(from, prop, val)
-      Interface::CFString.CFStringGetCStringPtr(val.read_pointer, 0).read_string
-    end
+      def load_sources
+        @sources = (0..(Interface.MIDIGetNumberOfSources()-1)).reduce([]) do |src, i|
+                     source_ptr = Interface.MIDIGetSource(i)
+                     src << get_property(:model, source_ptr)
+                   end
+      end
 
-    #---------------------------------------------------------------------------------------------------------
-    def create_client
-      client_name = Interface::CFString.CFStringCreateWithCString(nil, "Client #{@id}: #{@name}", 0)
-      client_ptr = FFI::MemoryPointer.new(:pointer)
-      Interface.MIDIClientCreate(client_name, nil, nil, client_ptr)
-      @client = client_ptr.read_pointer
-    end
+      def find_destination_index_for_name(name)
+        dest_index = (0..(@destinations.length-1)).find{|i| @destinations[i] == name}
+        dest_index.nil? ? raise(Zgomot::Error, "Destination '#{name}' not found") : dest_index
+      end
 
-    #---------------------------------------------------------------------------------------------------------
-    def connect_endpoint
-      port_name = Interface::CFString.CFStringCreateWithCString(nil, "Port #{@id}: #{@name}", 0)
-      outport_ptr = FFI::MemoryPointer.new(:pointer)
-      Interface.MIDIOutputPortCreate(@client, port_name, outport_ptr)
-      @endpoint = outport_ptr.read_pointer
-    end
+      def find_source_index_for_name(name)
+        src_index = (0..(@sources.length-1)).find{|i| @sources[i] == name}
+        src_index.nil? ? raise(Zgomot::Error, "Source '#{name}' not found") : src_index
+      end
+
+      def find_iac_destination
+        iac_index = find_destination_index_for_name('IAC Driver')
+        @destination = Interface.MIDIGetDestination(iac_index)
+        @output = @destinations[iac_index]
+      end
+
+      def get_property(name, from)
+        prop = Interface::CFString.CFStringCreateWithCString(nil, name.to_s, 0)
+        val = Interface::CFString.CFStringCreateWithCString(nil, name.to_s, 0)
+        Interface::MIDIObjectGetStringProperty(from, prop, val)
+        Interface::CFString.CFStringGetCStringPtr(val.read_pointer, 0).read_string
+      end
+
+      def create_client(name)
+        client_name = Interface::CFString.CFStringCreateWithCString(nil, name, 0)
+        client_ptr = FFI::MemoryPointer.new(:pointer)
+        Interface.MIDIClientCreate(client_name, nil, nil, client_ptr)
+        client_ptr.read_pointer
+      end
+
+      def create_output_port
+        port_name = Interface::CFString.CFStringCreateWithCString(nil, "Output-Port", 0)
+        outport_ptr = FFI::MemoryPointer.new(:pointer)
+        Interface::MIDIOutputPortCreate(@output_client, port_name, outport_ptr)
+        @output_port = outport_ptr.read_pointer
+      end
+
+      def create_input_port
+        port_name = Interface::CFString.CFStringCreateWithCString(nil, "Input-Port", 0)
+        inport_ptr = FFI::MemoryPointer.new(:pointer)
+        @input_callback = get_input_callback
+        Interface.MIDIInputPortCreate(@input_client, port_name, @input_callback, nil, inport_ptr)
+        @input_port = inport_ptr.read_pointer
+      end
+
+      def get_input_callback
+        ->(new_packets, refCon, connRefCon) do
+          packet = new_packets[:packet][0]
+          len = packet[:length]
+          if len > 0
+            bytes = packet[:data].to_a[0, len]
+            message_type = bytes.first
+            if message_type >= CC and message_type <= (CC | 0xf)
+              channel = message_type - CC
+              Zgomot::Midi::CC.apply(bytes[1], bytes[2], channel)
+            end
+          end
+        end
+      end
 
-    #---------------------------------------------------------------------------------------------------------
-    def get_destination
-      @destination = Interface.MIDIGetDestination(0)
-    end
-    
-  #### CoreMidi
   end
 
-#### Zgomot::Drivers
 end

data/lib/zgomot/drivers/driver.rb

@@ -1,7 +1,5 @@
-##############################################################################################################
 class Zgomot::Drivers
-  
-  #####-------------------------------------------------------------------------------------------------------
+
   class Driver
 
     #---------------------------------------------------------------------------------------------------------
@@ -28,42 +26,34 @@ class Zgomot::Drivers
     # Pitch bend
     PB  = 0xe0
 
-    #---------------------------------------------------------------------------------------------------------
     def initialize
       open
     end
-  
-    #---------------------------------------------------------------------------------------------------------
+
     def note_on(note, channel, velocity)
       write(ON | channel, note, velocity)
     end
 
-    #---------------------------------------------------------------------------------------------------------
     def note_off(note, channel, velocity = 0)
       write(OFF | channel, note, velocity)
     end
 
-    #---------------------------------------------------------------------------------------------------------
     def aftertouch(note, channel, pressure)
       write(PA | channel, note, pressure)
     end
 
-    #---------------------------------------------------------------------------------------------------------
     def control_change(number, channel, value)
       write(CC | channel, number, value)
     end
 
-    #---------------------------------------------------------------------------------------------------------
     def program_change(channel, program)
       write(PC | channel, program)
     end
 
-    #---------------------------------------------------------------------------------------------------------
     def channel_aftertouch(channel, pressure)
       write(CA | channel, pressure)
     end
 
-    #---------------------------------------------------------------------------------------------------------
     def pitch_bend(channel, value)
       write(PB | channel, value)
     end
@@ -75,13 +65,10 @@ class Zgomot::Drivers
       raise NotImplementedError, "You must implement #close in your driver."
     end
 
-    #---------------------------------------------------------------------------------------------------------
     def write(*args)
       raise NotImplementedError, "You must implement #write in your driver."
     end
 
-  #### Driver
   end
 
-#### Zgomot::Drivers
 end

data/lib/zgomot/drivers/mgr.rb

@@ -1,15 +1,11 @@
-##############################################################################################################
 class Zgomot::Drivers
-
-  #####-------------------------------------------------------------------------------------------------------
   class Mgr
-
-    #####-------------------------------------------------------------------------------------------------------
     class << self
-
-      #---------------------------------------------------------------------------------------------------------
+      extend Forwardable
+      def_delegators :@driver, :sources, :destinations, :input, :output,
+                               :add_input, :remove_input
       def load_driver
-        driver_name = self.driver_name        
+        driver_name = self.driver_name
         driver_path = "zgomot/drivers/#{driver_name}"
         Zgomot.logger.info "LOADING DRIVER: #{driver_path}"
         begin
@@ -18,11 +14,9 @@ class Zgomot::Drivers
           raise LoadError, "Could not load driver '#{driver_path}'."
         end
         driver_class = "Zgomot::Drivers::" + driver_name.split('_').map{|n| n.capitalize}.join
-        @driver = Object.module_eval("::#{driver_class}").new        
+        @driver = Object.module_eval("::#{driver_class}").new
         Zgomot.logger.info "DRIVER #{driver_class} CREATED"
       end
-
-      #---------------------------------------------------------------------------------------------------------
       def driver_name
         case RUBY_PLATFORM
           when /darwin/
@@ -31,20 +25,10 @@ class Zgomot::Drivers
            raise "platform not supported"
         end
       end
-
-      #---------------------------------------------------------------------------------------------------------
       def method_missing(method, *args)
         return @driver.send(method, *args)
       end
-
-    ## self
     end
-
-    #-----------------------------------------------------------------------------------------------------------
     load_driver
-  
-  #### Mgr
   end
-
-#### Zgomot::Driver 
 end

data/lib/zgomot/main.rb

@@ -1,13 +1,6 @@
-##############################################################################################################
 module Zgomot
-  
-  #####-------------------------------------------------------------------------------------------------------
-  module Delegator 
-
-    #####-------------------------------------------------------------------------------------------------------
+  module Delegator
     class << self
-
-      #.........................................................................................................
       def delegate(del, *methods)
         methods.each do |method_name|
           class_eval <<-RUBY
@@ -17,35 +10,31 @@ module Zgomot
           RUBY
         end
       end
-
-    #### self
     end
-
     delegate Zgomot::Boot, :before_start
-    delegate Zgomot::Midi::Stream, :str, :play, :streams
-    delegate Zgomot::Midi::Channel, :ch
-    delegate Zgomot::Midi::Dispatcher, :clock
+    delegate Zgomot::Midi::Clock, :set_config
+    delegate Zgomot::Midi::Stream, :str, :run, :play, :pause, :stop, :tog
+    delegate Zgomot::Midi::Dispatcher, :clk
+    delegate Zgomot::Midi::CC, :cc, :add_cc, :learn_cc
     delegate Zgomot::Comp::Pattern, :np, :cp, :c, :n, :pr
     delegate Zgomot::Comp::Markov, :mark
-
-  #### Delegator 
+    delegate Zgomot::Drivers::Mgr, :sources, :destinations, :input, :output,
+             :add_input, :remove_input
+    delegate Zgomot::UI::MainWindow, :dash
+    delegate Zgomot::UI::Output, :lstr, :lcc, :lconfig
   end
-    
-#### AgentXmpp 
 end
 
-##############################################################################################################
 include Zgomot::Delegator
 
-##############################################################################################################
-at_exit do 
+at_exit do
   unless Zgomot.live
     Zgomot::Boot.boot
-    Zgomot::Midi::Stream.streams.each{|s| s.thread.join}
-    loop do     
+    Zgomot::Midi::Stream.streams.each{|s| s.thread.join unless s.thread.nil?}
+    loop do
       break if Zgomot::Midi::Dispatcher.done?
       sleep(Zgomot::DISPATCHER_POLL)
     end
   end
-  Zgomot.logger.info "ZGOMOT IS FINISHED"    
+  Zgomot.logger.info "ZGOMOT IS FINISHED"
 end

data/lib/zgomot/midi/cc.rb

@@ -0,0 +1,67 @@
+module Zgomot::Midi
+  class CC
+
+    @params = {}
+    @ccs = {}
+
+    class << self
+
+      attr_reader :ccs, :params
+
+      def add_cc(name, cc, args)
+        channel = args[:channel].nil? ? 1 : args[:channel]
+        min = args[:min].nil? ? 0.0 : args[:min]
+        max = args[:max].nil? ? 1.0 : args[:max]
+        type = args[:type] || :cont
+        init = args[:init].nil? ? (type == :cont ? 0.0 : false) : args[:init]
+        @ccs[cc] = name.to_sym
+        (@params[name] ||= {})[channel] = {:min         => min,
+                                           :max         => max,
+                                           :value       => init,
+                                           :type        => type,
+                                           :updated_at  => ::Time.now,
+                                           :cc          => cc}
+        Zgomot.logger.info "ADDED CC #{cc}:#{name}:#{init}:#{channel}"
+      end
+      def learn_cc(name, cc, args)
+      end
+      def cc(name, channel = 1)
+        raise(Zgomot::Error, " CC '#{name}' for channel '#{channel}' not found") if @params[name].nil? or @params[name][channel].nil?
+        @params[name][channel][:value]
+      end
+      def channel_info(name, channel, config)
+        val, max, min = if config[:type] == :cont
+                          ["%3.2f" % config[:value], "%3.2f" % config[:max], "%3.2f" % config[:min]]
+                        else
+                          [config[:value].to_s, '-', '-']
+                        end
+        [name, val, config[:cc].to_s, channel.to_s, config[:type].to_s, max, min]
+      end
+      def cc_names
+        params.keys
+      end
+      def info(name)
+        params[name].map{|(ch, config)| channel_info(name, ch, config)}
+      end
+      def update_at(name, ch)
+        params[name.to_sym][ch.to_i][:updated_at]
+      end
+      def apply(cc_num, value, channel)
+        name = @ccs[cc_num]
+        unless name.nil?
+          Zgomot.logger.info "UPDATED CC #{cc_num}:#{name}:#{value}:#{channel}"
+          p = @params[name][channel]
+          p[:updated_at] = ::Time.now
+          min = p[:min]
+          max = p[:max]
+          if p[:type] == :cont
+            p[:value] = min + (max - min)*value.to_f/127.0
+          else
+            p[:value] = value == 127 ? true : false
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/zgomot/midi/channel.rb

@@ -1,92 +1,62 @@
-##############################################################################################################
 module Zgomot::Midi
 
-  #####-------------------------------------------------------------------------------------------------------
   class Channel
 
-    #.........................................................................................................
     @channels = []
-    
-    #####-------------------------------------------------------------------------------------------------------
+
     class << self
-      
-      #.........................................................................................................
+
       attr_reader :channels
 
-      #.........................................................................................................
-      def ch(num=0, opts={})
-        (channels << new(is_valid(num), opts)).last
+      def ch(num=0)
+        (channels << new(is_valid(num))).last
       end
 
-      #.........................................................................................................
       def is_valid(num)
         nums = [num].flatten
         valid = nums.select{|n| 0 <= n and n <= 15}
         valid.length.eql?(nums.length) ? num : raise(Zgomot::Error, "channel number invalid: 1<= channel <= 16")
       end
 
-      #.........................................................................................................
       def release(chan)
         channels.delete_if{|c| c.eql?(chan)}
       end
 
-    #### self
     end
-    
-    #####-------------------------------------------------------------------------------------------------------
-    attr_reader :number, :clock, :pattern
-    
-    #.........................................................................................................
-    def initialize(num, opts={})
-      @number = num
-      @clock = Clock.new
-      @pattern = []
+
+    attr_reader :number, :clock, :pattern, :length_to_sec
+
+    def initialize(num)
+      @number, @pattern = num, []
+      set_clock
     end
 
-    #.........................................................................................................
     def <<(pat)
+      @pattern.clear
+      @length_to_sec = 0.0
       pat = Zgomot::Comp::Pattern.new(pat) unless pat.kind_of?(Zgomot::Comp::Pattern)
-      pat.seq.each do |p| 
+      pat.seq.each do |p|
         p.time = clock.current_time
+        p_sec = p.length_to_sec
         p.channel = number
+        @length_to_sec += p_sec
+        clock.update(p_sec)
         @pattern << Marshal.load(Marshal.dump(p))
-        clock.update(p.length_to_sec)
       end; self
     end
 
-    #.........................................................................................................
     def method_missing(meth, *args, &blk )
       pattern.send(meth, *args, &blk); reset_pattern_time; self
     end
 
-    #.........................................................................................................
-    def length_to_sec
-      clock.current_time.to_f
-    end
-
-    #.........................................................................................................
-    # transforms
-    #.........................................................................................................
     def time_shift(secs)
-      pattern.each{|p| p.offset_time=secs}; self
+      pattern.each{|p| p.offset_time= secs}; self
     end
-    
-    #.........................................................................................................
-    # pattern
-    #.........................................................................................................
-    def reset_pattern_time
+
+    def set_clock
       @clock = Clock.new
-      pattern.each do |pat| 
-        pat.time = clock.current_time
-        clock.update(pat.length_to_sec)
-      end
     end
-    
-    #.........................................................................................................
-    private :reset_pattern_time
-    
-  #### Channel
+
   end
 
-#### Zgomot::Midi 
 end