shmidi 0.1

data/lib/shmidi/ffi-coremidi-patch.rb

@@ -0,0 +1,259 @@
+module CoreMIDI
+
+  # Type of endpoint used for input
+  class Source
+
+    include Endpoint
+
+    attr_reader :buffer
+
+    #
+    # An array of MIDI event hashes as such:
+    #   [
+    #     { :data => [144, 60, 100], :timestamp => 1024 },
+    #     { :data => [128, 60, 100], :timestamp => 1100 },
+    #     { :data => [144, 40, 120], :timestamp => 1200 }
+    #   ]
+    #
+    # The data is an array of Numeric bytes
+    # The timestamp is the number of millis since this input was enabled
+    #
+    # @return [Array<Hash>]
+    def gets
+      # SINM ADDED
+      @queue.pop
+      # SINM COMMENTED OUT
+      # until queued_messages?
+      #   # per https://github.com/arirusso/unimidi/issues/20#issuecomment-44761318
+      #   sleep(0.0001) # patch to prevent 100% CPU issue with some midi controllers
+      # end
+      # messages = queued_messages
+      # @pointer = @buffer.length
+      # messages
+    end
+    alias_method :read, :gets
+
+    # Same as Source#gets except that it returns message data as string of hex
+    # digits as such:
+    #   [
+    #     { :data => "904060", :timestamp => 904 },
+    #     { :data => "804060", :timestamp => 1150 },
+    #     { :data => "90447F", :timestamp => 1300 }
+    #   ]
+    #
+    # @return [Array<Hash>]
+    def gets_s
+      messages = gets
+      messages.each do |message|
+        message[:data] = TypeConversion.numeric_bytes_to_hex_string(message[:data])
+      end
+      messages
+    end
+    alias_method :gets_bytestr, :gets_s
+
+    # Enable this the input for use; can be passed a block
+    # @return [Source]
+    def enable(options = {}, &block)
+      @enabled = true unless @enabled
+      if block_given?
+        begin
+          yield(self)
+        ensure
+          close
+        end
+      end
+      self
+    end
+    alias_method :open, :enable
+    alias_method :start, :enable
+
+    # Close this input
+    # @return [Boolean]
+    def close
+      #error = API.MIDIPortDisconnectSource( @handle, @resource )
+      #raise "MIDIPortDisconnectSource returned error code #{error}" unless error.zero?
+      #error = API.MIDIClientDispose(@handle)
+      #raise "MIDIClientDispose returned error code #{error}" unless error.zero?
+      #error = API.MIDIPortDispose(@handle)
+      #raise "MIDIPortDispose returned error code #{error}" unless error.zero?
+      #error = API.MIDIEndpointDispose(@resource)
+      #raise "MIDIEndpointDispose returned error code #{error}" unless error.zero?
+      if @enabled
+        @enabled = false
+        true
+      else
+        false
+      end
+    end
+
+    # Shortcut to the first available input endpoint
+    # @return [Source]
+    def self.first
+      Endpoint.first(:source)
+    end
+
+    # Shortcut to the last available input endpoint
+    # @return [Source]
+    def self.last
+      Endpoint.last(:source)
+    end
+
+    # All input endpoints
+    # @return [Array<Source>]
+    def self.all
+      Endpoint.all_by_type[:source]
+    end
+
+    protected
+
+    # Base initialization for this endpoint -- done whether or not the endpoint is enabled to check whether
+    # it is truly available for use
+    def connect
+      enable_client
+      initialize_port
+      @resource = API.MIDIEntityGetSource(@entity.resource, @resource_id)
+      error = API.MIDIPortConnectSource(@handle, @resource, nil )
+      initialize_buffer
+      # SINM ADDED
+      @queue = Queue.new
+
+      @sysex_buffer = []
+      @start_time = Time.now.to_f
+
+      error.zero?
+    end
+    alias_method :connect?, :connect
+
+    private
+
+    # Add a single message to the buffer
+    # @param [Array<Fixnum>] bytes Message data
+    # @param [Float] timestamp The system float timestamp
+    # @return [Array<Hash>] The resulting buffer
+    def enqueue_message(bytes, timestamp)
+      if bytes.first.eql?(0xF0) || !@sysex_buffer.empty?
+        @sysex_buffer += bytes
+        if bytes.last.eql?(0xF7)
+          bytes = @sysex_buffer.dup
+          @sysex_buffer.clear
+        end
+      end
+      # SINM ADDED
+      @sysex_buffer.empty? ? get_message_formatted(bytes, timestamp) : nil
+      # SINM COMMENTED OUT
+      # @buffer << get_message_formatted(bytes, timestamp) if @sysex_buffer.empty?
+      # @buffer
+    end
+
+    # New MIDI messages from the queue
+    def queued_messages
+      @buffer.slice(@pointer, @buffer.length - @pointer)
+    end
+
+    # Are there new MIDI messages in the queue?
+    def queued_messages?
+      @pointer < @buffer.length
+    end
+
+    # The callback fired by coremidi when new MIDI messages are in the buffer
+    def get_event_callback
+      Proc.new do |new_packets, refCon_ptr, connRefCon_ptr|
+        begin
+          # p "packets received: #{new_packets[:numPackets]}"
+          timestamp = Time.now.to_f
+          messages = get_messages(new_packets)
+          # SINM ADDED
+          @queue.push(messages.map do |message|
+            enqueue_message(message, timestamp)
+          end.compact)
+          # SINM COMMENTED OUT
+          # messages.each { |message| enqueue_message(message, timestamp) }
+        rescue Exception => exception
+          Thread.main.raise(exception)
+        end
+      end
+    end
+
+    # Get MIDI messages from the given CoreMIDI packet list
+    # @param [API::MIDIPacketList] new_packets The packet list
+    # @return [Array<Array<Fixnum>>] A collection of MIDI messages
+    def get_messages(packet_list)
+      count = packet_list[:numPackets]
+      first = packet_list[:packet][0]
+      data = first[:data].to_a
+      messages = []
+      messages << data.slice!(0, first[:length])
+      (count - 1).times do |i|
+        length_index = find_next_length_index(data)
+        message_length = data[length_index]
+        unless message_length.nil?
+          packet_start_index = length_index + 2
+          packet_end_index = packet_start_index + message_length
+          if data.length >= packet_end_index + 1
+            packet = data.slice!(0..packet_end_index)
+            message = packet.slice(packet_start_index, message_length)
+            messages << message
+          end
+        end
+      end
+      messages
+    end
+
+    # Get the next index for "length" from the blob of MIDI data
+    # @param [Array<Fixnum>] data
+    # @return [Fixnum]
+    def find_next_length_index(data)
+      last_is_zero = false
+      data.each_with_index do |num, i|
+        if num.zero?
+          if last_is_zero
+            return i + 1
+          else
+            last_is_zero = true
+          end
+        else
+          last_is_zero = false
+        end
+      end
+    end
+
+    # Timestamp for a received MIDI message
+    # @return [Fixnum]
+    def timestamp(now)
+      (now - @start_time) * 1000
+    end
+
+    # Give a message its timestamp and package it in a Hash
+    # @return [Hash]
+    def get_message_formatted(raw, time)
+      {
+        :data => raw,
+        :timestamp => timestamp(time)
+      }
+    end
+
+    # Initialize a coremidi port for this endpoint
+    # @return [Boolean]
+    def initialize_port
+      @callback = get_event_callback
+      port = API.create_midi_input_port(@client, @resource_id, @name, @callback)
+      @handle = port[:handle]
+      raise "MIDIInputPortCreate returned error code #{port[:error]}" unless port[:error].zero?
+      true
+    end
+
+    # Initialize the MIDI message buffer
+    # @return [Boolean]
+    def initialize_buffer
+      @pointer = 0
+      @buffer = []
+      def @buffer.clear
+        super
+        @pointer = 0
+      end
+      true
+    end
+
+  end
+
+end

data/lib/shmidi/led_button.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+module Shmidi
+  class LedButton < Control
+    CTYPE = :LEDBUT
+    attr_reader :button, :led
+
+    def initialize(id, socket, channel, note, led_note = nil)
+      super(id, socket, channel, note)
+      @button = Button.new(id, socket, channel, note)
+      @led = Led.new(id, socket, channel, led_note || note)
+      @button.on_press(&lambda { |button| on_button_press(button) })
+      @button.on_release(&lambda { |button| on_button_release(button) })
+    end
+
+    protected
+
+    def on_button_press(button)
+      @led.turn_on
+    end
+
+    def on_button_release(button)
+      @led.turn_off
+    end
+  end
+end

data/lib/shmidi/on_off_clock.rb

@@ -0,0 +1,27 @@
+# coding: utf-8
+module Shmidi
+  class OnOffClock < Clock
+    def initialize(socket, delay = 0.2, delay_off = 0.2)
+      @next_on = false
+      super(socket, delay)
+      @delay_off = delay_off
+    end
+
+    protected
+
+    def filter
+      b = @buffer
+      @buffer = []
+      bb = b.select { |e| e.message == (@next_on ? :on : :off) }
+      b = b - bb
+      @buffer = @buffer + b
+      bb
+    end
+
+    def wait
+      d = @next_on ? @delay : @delay_off
+      @next_on = !@next_on
+      sleep(d)
+    end
+  end
+end

data/lib/shmidi/socket.rb

@@ -0,0 +1,78 @@
+# coding: utf-8
+module Shmidi
+  class Socket
+    include Base
+
+    @@controllers = {}
+    def self.[](name)
+      @@controllers[name]
+    end
+
+    attr_reader :name, :in, :out
+
+    def initialize(name, in_id, out_id)
+      @name = name
+      @in = in_id
+      @out = out_id
+      init
+    end
+
+    def init
+      @__in_dev   = UniMIDI::Input.all.find { |d| d.name == @in  }
+      @__out_dev  = UniMIDI::Output.all.find { |d| d.name == @out }
+
+      @@controllers[@name] = self
+      @__queue = Queue.new
+      @__on_event = []
+      # @__sync_threads = Hash.new { |hash, key| hash[key] = Clock.new(key, self) }
+      @__listener = Thread.new do
+        loop do
+          break unless @__in_dev
+          begin
+            @__in_dev.gets.each do |event|
+              event[:source] = @name
+              event = Event.new(event)
+              Shmidi.TRACE_INTERNAL("> #{@name}\t#{event}")
+              @__queue.push(event)
+              @__on_event.each do |rule|
+                next if (channel  = rule[:channel]) && channel  != event.channel
+                next if (message  = rule[:message]) && message  != event.message
+                next if (note     = rule[:note])    && note     != event.note
+                next if (value    = rule[:value])   && value    != event.value
+
+                rule[:block].call(event) rescue Shmidi.ON_EXCEPTION
+              end
+            end
+          rescue
+            Shmidi.ON_EXCEPTION
+          end
+        end
+      end
+    end
+
+    def on_event(channel = nil, message = nil, note = nil, value = nil, &block)
+      @__on_event << {
+        :block => block,
+        :channel => channel,
+        :message => message,
+        :note => note
+      }
+    end
+
+    def push(events)
+      events = Array(events).reduce([]) do |array, event|
+        Shmidi.TRACE_EXTERNAL("< #{@name}\t#{event}")
+        array << event.data
+        array
+      end
+      @__out_dev.puts(*events)
+    end
+
+    def self.print_device_list
+      $stdout.puts('Inputs:')
+      UniMIDI::Input.list
+      $stdout.puts('Outputs:')
+      UniMIDI::Output.list
+    end
+  end
+end

data/lib/shmidi/switch.rb

@@ -0,0 +1,28 @@
+# coding: utf-8
+module Shmidi
+  class Switch < LedButton
+    CTYPE = :SWI
+    attr_reader :switch_state
+    def initialize(id, socket, channel, note, led_note = nil)
+      super(id, socket, channel, note, led_note)
+      @switch_state = false
+      @on_switch = []
+    end
+
+    def on_switch_state(&block)
+      @on_switch << block
+    end
+
+    protected
+
+    def on_button_press(button)
+      (@switch_state = !@switch_state) ? @led.turn_on : @led.turn_off
+      Shmidi.TRACE("#{CTYPE}\t#{@id}\tSTATE\t#{@switch_state ? :ON : :OFF}")
+      @on_switch.each { |b| b.call(self) }
+    end
+
+    def on_button_release(button)
+      nil
+    end
+  end
+end

data/lib/shmidi/version.rb

@@ -0,0 +1,5 @@
+# coding: utf-8
+
+module Shmidi
+  VERSION = '0.1'
+end

data/lib/shmidi.rb

@@ -0,0 +1,100 @@
+# coding: utf-8
+require 'shmidi/version'
+
+require 'timeout'
+
+require 'unimidi'
+require 'shmidi/ffi-coremidi-patch'
+
+module Shmidi
+  PROFILE         = !!ENV['PROFILE']
+  TRACE           = !!ENV['TRACE']
+  TRACE_EXTERNAL  = !!ENV['TRACE_EXTERNAL']
+  TRACE_INTERNAL  = !!ENV['TRACE_INTERNAL']
+
+  def self.timestamp
+    t = Time.now
+    (t.to_i * 1000) + (t.usec / 1000)
+  end
+
+  @@trace_queue = Queue.new
+  @@trace_thread = Thread.new do
+    loop do
+      begin
+        str = @@trace_queue.pop
+        $stderr.puts("#{timestamp}\t#{str}")
+      rescue
+        $stderr.puts("Error in trace thread: #{$!}")
+      end
+    end
+  end
+
+  def self.TRACE(str)
+    return nil unless TRACE
+    @@trace_queue.push(str)
+  end
+
+  def self.TRACE_EXTERNAL(str)
+    return nil unless TRACE_EXTERNAL
+    @@trace_queue.push(str)
+  end
+
+  def self.TRACE_INTERNAL(str)
+    return nil unless TRACE_INTERNAL
+    @@trace_queue.push(str)
+  end
+
+  def self.ON_EXCEPTION
+    back = $!.backtrace.join("\n\t\t")
+    @@trace_queue.push("ERROR\t#{$!.class.name}:#{$!}\n\t\t#{back}")
+  end
+
+  require 'oj'
+  JSON_CREATE_ID = 'm_type'
+  ::Oj.default_options = {
+    :mode         => :compat,
+    :class_cache  => true,
+    :create_id    => JSON_CREATE_ID,
+    :time         => :unix
+  }
+
+  def self.DUMP(obj, opts={})
+    Oj.dump((obj.kind_of?(Base) ? obj.to_hash : obj), opts)
+  end
+
+  def self.JSON_PARSE str, opts = {:warn => true}
+    return nil if str.nil?
+    Oj.load(str, opts)
+  rescue
+    if opts[:warn]
+      Shmidi::ON_EXCEPTION
+      TRACE "#{str}".force_encoding(Encoding::UTF_8)
+    end
+    nil
+  end
+
+  def self.PRETTY obj
+    DUMP((obj.kind_of?(String) ? JSON_PARSE(obj) : obj), :indent=>2)
+  end
+end
+
+require 'shmidi/base'
+
+require 'shmidi/socket'
+require 'shmidi/event'
+require 'shmidi/controller'
+
+require 'shmidi/clock'
+  require 'shmidi/on_off_clock'
+
+require 'shmidi/control'
+  require 'shmidi/controls/led'
+    require 'shmidi/composite/rgy_led'
+  require 'shmidi/controls/knob'
+    require 'shmidi/controls/fader'
+    require 'shmidi/controls/encoder'
+  require 'shmidi/controls/button'
+    require 'shmidi/led_button'
+      require 'shmidi/switch'
+
+

data/shmidi.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+require File.expand_path('../lib/shmidi/version.rb', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name          = 'shmidi'
+  s.version       = Shmidi::VERSION
+  s.authors       = ['sinm']
+  s.email         = 'sinm.sinm@gmail.com'
+  s.summary       = 'Midi experiments'
+  s.description   = '== Midi experiments'
+  s.homepage      = 'https://github.com/sinm/shmidi'
+  s.license       = 'MIT'
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/`.split("\n")
+  s.require_paths = ['lib']
+  s.bindir        = 'bin'
+  s.executables   = `git ls-files -- bin/`.split("\n").map{|f| File.basename(f)}
+  s.add_development_dependency 'bundler',    '~> 1.7'
+  s.add_development_dependency 'rake',       '~> 10.1'
+  s.add_development_dependency 'minitest',   '~> 4.7'
+  # NOTE: it's useful to install
+  # specified version of perftools.rb w/o bundler first
+  s.add_development_dependency 'perftools.rb', '~> 2.0.4'
+  s.add_dependency 'ffi-coremidi',  '0.3.8'
+  s.add_dependency 'unimidi',       '0.4.6'
+  s.add_dependency 'argparser',     '~> 2.1'
+  s.add_dependency 'oj',            '~> 2.12.12'
+end

data/shmidi.sublime-project

@@ -0,0 +1,30 @@
+{
+	"folders":
+	[
+		{
+			"path": "."
+		},
+    {
+      "path": "~/.rbenv/versions/2.1.2/lib/ruby/gems/2.1.0/gems"
+    }
+	],
+  "build_systems":
+  [
+    {
+        "name": "Run tests",
+        "cmd": ["bundle", "exec", "rake", "test"],
+        "selector": "source.rb"
+    }
+  ],
+  "settings":
+  {
+    "ensure_newline_at_eof_on_save": true,
+    "rulers":
+    [
+      80
+    ],
+    "tab_size": 2,
+    "translate_tabs_to_spaces": true,
+    "trim_trailing_white_space_on_save": true
+  }
+}

data/test/xonek1-ledtest.json

@@ -0,0 +1,42 @@
+{
+  "m_type":"Shmidi::Controller",
+  "name":"xonek1-ledtest",
+  "internals":[
+    [
+      {
+        "m_type":"Shmidi::Socket",
+        "name":"xone",
+        "in":"ALLEN&HEATH LTD. XONE:K1",
+        "out":"ALLEN&HEATH LTD. XONE:K1"
+      }
+    ],
+    {
+      "led":{
+        "m_type":"Shmidi::RGYLed",
+        "leds":{
+          "red":{
+            "m_type":"Shmidi::Led",
+            "socket":"xone",
+            "channel":15,
+            "note":"C0",
+            "turned_on":false
+          },
+          "green":{
+            "m_type":"Shmidi::Led",
+            "socket":"xone",
+            "channel":15,
+            "note":"G#0",
+            "turned_on":false
+          },
+          "yellow":{
+            "m_type":"Shmidi::Led",
+            "socket":"xone",
+            "channel":15,
+            "note":"E0",
+            "turned_on":false
+          }
+        }
+      }
+    }
+  ]
+}