midi-message 0.2.2

data/lib/midi-message/process/transpose.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+module MIDIMessage
+
+  module Process
+    
+    class Transpose
+
+      include Processor
+
+      attr_reader :factor, :property
+      
+      def initialize(message, prop, factor, options = {})
+        @factor = factor
+        @message = message
+        @property = prop
+        initialize_processor(message)
+      end
+
+      def process
+        val = @message.send(@property)
+        @message.send("#{@property}=", val + @factor)
+        @message
+      end
+
+    end
+
+  end
+  
+end

data/lib/midi-message/short_message.rb

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+#
+
+module MIDIMessage
+
+  # common behavior amongst all Message types
+  module ShortMessage
+
+    attr_reader :name,
+                :status,
+                :verbose_name
+                  
+    def initialize_short_message(status_nibble_1, status_nibble_2)
+      @status = [status_nibble_1, status_nibble_2]
+      populate_using_const
+    end
+    
+    # byte array representation of the object eg [0x90, 0x40, 0x40] for NoteOn(0x40, 0x40)
+    def to_a
+      data = @data.nil? ? [] : [@data[0], @data[1]] 
+      [(@status[0] << 4) + @status[1], *data].compact
+    end
+    alias_method :to_byte_a, :to_a
+    alias_method :to_byte_array, :to_a
+    alias_method :to_bytes, :to_a
+
+    # string representation of the object's bytes eg "904040" for NoteOn(0x40, 0x40)
+    def to_hex_s
+      TypeConversion.numeric_byte_array_to_hex_string(to_a)
+    end
+    alias_method :to_bytestr, :to_hex_s
+    
+    protected
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    def update
+      populate_using_const
+    end
+    
+    private
+    
+    # this will populate message metadata with information gathered from midi.yml
+    def populate_using_const
+      const_group_name = self.class.display_name
+      group_name_alias = self.class.constants
+      prop = self.class.map_constants_to
+      val = self.send(prop) unless prop.nil?
+      val ||= @status[1] # default property to use for constants
+      group = ConstantGroup[group_name_alias] || ConstantGroup[const_group_name]
+      unless group.nil?
+        const = group.find_by_value(val)
+        unless const.nil?
+          @const = const
+          @name = @const.nil? ? const.key : @const.key
+          @verbose_name = "#{self.class.display_name}: #{@name}"          
+        end
+      end      
+    end
+
+    module ClassMethods
+      
+      attr_reader :display_name, :constants, :map_constants_to 
+      
+      def get_constant(name)        
+        key = @constants || @display_name
+        unless key.nil?
+          group = ConstantGroup[key]
+          group.find(name)
+        end 
+      end
+
+      # this returns a builder for the class, preloaded with the selected const
+      def [](const_name)
+        const = get_constant(const_name)
+        MessageBuilder.new(self, const) unless const.nil?
+      end
+      
+      def use_display_name(name)
+        @display_name = name
+      end
+
+      def use_constants(name, options = {}) 
+        @map_constants_to = options[:for]
+        @constants = name
+      end
+
+    end
+
+  end
+
+  class MessageBuilder
+
+    def initialize(klass, const)      
+      @klass = klass      
+      @const = const
+    end
+
+    def new(*a)    
+      a.last.kind_of?(Hash) ? a.last[:const] = @const : a.push(:const => @const)         
+      @klass.new(*a)
+    end
+
+  end
+  
+  # shortcuts for dealing with message status
+  module Status
+    
+    # this returns the value of the Status constant with the name status_name
+    def self.[](status_name)
+      const = Constant.find("Status", status_name)
+      const.value unless const.nil?
+    end    
+    
+  end
+
+end

data/lib/midi-message/system_exclusive.rb

@@ -0,0 +1,202 @@
+#!/usr/bin/env ruby
+#
+
+module MIDIMessage
+
+  # MIDI System-Exclusive Messages (SysEx)
+  module SystemExclusive
+
+    # basic SysEx data that a message class will contain
+    module Base
+
+      attr_accessor :node
+      attr_reader :address,
+                  :checksum
+
+      StartByte = 0xF0
+      EndByte = 0xF7
+      
+      # an array of message parts.  multiple byte parts will be represented as an array of bytes
+      def to_a
+        # this may need to be cached when properties are updated
+        # might be worth benchmarking
+        [
+          self.class::StartByte,
+          @node.manufacturer_id,
+          @node.device_id, # (@device_id || @node.device_id) ?? dunno
+          @node.model_id,
+          type_byte,
+          [address].flatten,
+          [value].flatten,
+          checksum,
+          self.class::EndByte
+        ]
+      end
+
+      # a flat array of message bytes
+      def to_numeric_byte_array
+        to_a.flatten
+      end
+      alias_method :to_numeric_bytes, :to_numeric_byte_array
+      alias_method :to_byte_array, :to_numeric_byte_array
+      alias_method :to_bytes, :to_numeric_byte_array
+      alias_method :to_byte_a, :to_numeric_byte_array
+      
+      # string representation of the object's bytes
+      def to_hex_s
+        to_bytes.map { |b| s = b.to_s(16); s.length.eql?(1) ? "0#{s}" : s }.join.upcase
+      end
+      alias_method :to_bytestr, :to_hex_s
+      
+      def name
+        "System Exclusive"
+      end
+      alias_method :verbose_name, :name
+
+      def type_byte
+        self.class::TypeByte
+      end
+      
+      # alternate method from
+      # http://www.2writers.com/eddie/TutSysEx.htm
+      def checksum
+        sum = (address + [value].flatten).inject { |a, b| a + b } 
+        (128 - sum.divmod(128)[1])
+      end
+      
+      private
+
+      def initialize_sysex(address, options = {})
+        @node = options[:node]
+        @checksum = options[:checksum]
+        @address = address
+      end
+      
+    end
+
+    # A SysEx command message
+    # a command message is identified by having a status byte equal to 0x12
+    #
+    class Command
+
+      include Base
+
+      attr_reader :data
+      alias_method :value, :data
+      #alias_method :value=, :data=
+
+      TypeByte = 0x12
+      
+      def initialize(address, data, options = {})
+        # store as a byte if it's a single byte
+        @data = (data.kind_of?(Array) && data.length.eql?(1)) ? data[0] : data
+        initialize_sysex(address, options)
+      end
+      
+    end
+    
+    # A SysEx request message
+    # A request message is identified by having a status byte equal to 0x11
+    #
+    class Request
+
+      include Base
+      
+      attr_reader :size
+
+      alias_method :value, :size
+
+      TypeByte = 0x11
+      
+      def initialize(address, size, options = {})
+        self.size = (size.kind_of?(Array) && size.length.eql?(1)) ? size[0] : size
+        initialize_sysex(address, options)
+      end
+      
+      def size=(val)
+        # accepts a Numeric or Array but
+        # must always store value as an array of three bytes
+        size = []
+        if val.kind_of?(Array) && val.size <= 3
+          size = val
+        elsif val.kind_of?(Numeric) && (((val + 1) / 247) <= 2)
+          size = []
+          div, mod = *val.divmod(247)
+          size << mod unless mod.zero?
+          div.times { size << 247 }
+        end
+        (3 - size.size).times { size.unshift 0 }
+        @size = size
+      end
+      
+    end
+
+    #
+    # The SystemExclusive::Node represents a destination for a message.  For example a hardware 
+    # synthesizer or sampler
+    #
+    class Node
+
+      attr_accessor :device_id
+      attr_reader :manufacturer_id, :model_id
+      
+      def initialize(manufacturer, options = {})
+        @device_id = options[:device_id]
+        @model_id = options[:model_id]
+        @manufacturer_id = manufacturer.kind_of?(Numeric) ? manufacturer : Constant.find("Manufacturer", manufacturer).value
+      end
+
+      # this message takes a prototype message, copies it, and returns the copy with its node set
+      # to this node
+      def new_message_from(prototype_message)
+        copy = prototype_message.clone
+        copy.node = self
+        copy
+      end
+      
+      # create a new Command message associated with this node
+      def command(*a)
+        command = Command.new(*a)
+        command.node = self
+        command
+      end
+      
+      # create a new Request message associated with this node
+      def request(*a)
+        request = Request.new(*a)
+        request.node = self
+        request
+      end
+
+    end
+    
+    # convert raw MIDI data to SysEx message objects
+    def self.new(*bytes)
+
+      start_status = bytes.shift
+      end_status = bytes.pop
+
+      return nil unless start_status.eql?(0xF0) && end_status.eql?(0xF7)
+
+      fixed_length_message_part = bytes.slice!(0,7)
+
+      manufacturer_id = fixed_length_message_part[0]
+      device_id = fixed_length_message_part[1]
+      model_id = fixed_length_message_part[2]
+
+      msg_class = case fixed_length_message_part[3]
+        when 0x11 then Request
+        when 0x12 then Command
+      end
+
+      address = fixed_length_message_part.slice(4,3)
+      checksum = bytes.slice!((bytes.length - 1), 1)
+      value = bytes
+
+      node = Node.new(manufacturer_id, :model_id => model_id, :device_id => device_id)
+      msg_class.new(address, value, :checksum => checksum, :node => node)
+    end
+
+  end
+
+end

data/lib/midi-message/system_message.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+#
+
+module MIDIMessage
+  
+  #
+  # MIDI System-Common message
+  #
+  class SystemCommon
+
+    include ShortMessage
+    use_display_name 'System Common'
+    
+    attr_reader :data
+    
+    def initialize(*a)
+      options = a.last.kind_of?(Hash) ? a.pop : {}
+      @const = options[:const]
+      @data = [a[1], a[2]]
+      second_nibble = @const.nil? ? a[0] : @const.value 
+      initialize_short_message(0xF, second_nibble)
+    end
+    
+  end  
+  
+  #
+  # MIDI System-Realtime message
+  #
+  class SystemRealtime
+
+    include ShortMessage
+    use_display_name 'System Realtime'
+    
+    def initialize(*a)
+      options = a.last.kind_of?(Hash) ? a.pop : {} 
+      @const = options[:const]
+      id = @const.nil? ? a[0] : @const.value
+      initialize_short_message(0xF, id)
+    end
+
+    def id
+      @status[1]
+    end
+
+  end
+  
+end

data/lib/midi-message/type_conversion.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+#
+module MIDIMessage
+ 
+  # this is a helper for converting nibbles and bytes
+  module TypeConversion
+    
+    def self.hex_chars_to_numeric_byte_array(nibbles)
+      nibbles = nibbles.dup
+      # get rid of last nibble if there's an odd number
+      # it will be processed later anyway
+      nibbles.slice!(nibbles.length-2, 1) if nibbles.length.odd?
+      bytes = []
+      while !(nibs = nibbles.slice!(0,2)).empty?
+        byte = (nibs[0].hex << 4) + nibs[1].hex
+        bytes << byte
+      end
+      bytes
+    end
+    
+    # convert byte str to byte array 
+    def self.hex_string_to_numeric_byte_array(str)
+      str = str.dup
+      bytes = []
+      until str.eql?("")
+        bytes << str.slice!(0, 2).hex
+      end
+      bytes
+    end
+    
+    # converts a string of hex digits to bytes
+    def self.hex_str_to_hex_chars(str)
+      str.split(//)    
+    end
+    
+    def self.numeric_byte_array_to_hex_string(bytes)
+      bytes.map { |b| s = b.to_s(16); s.length.eql?(1) ? "0#{s}" : s }.join.upcase
+    end
+    
+    def self.numeric_byte_to_hex_chars(num)
+      [((num & 0xF0) >> 4), (num & 0x0F)].map { |n| n.to_s(16) }      
+    end
+
+    
+  end
+  
+end

data/lib/midi-message.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+#
+# MIDI Messages in Ruby
+# (c)2011 Ari Russo and licensed under the Apache 2.0 License
+# 
+module MIDIMessage
+  
+  module Process    
+  end
+  
+  VERSION = "0.2.2"
+ 
+end
+
+require 'yaml'
+
+# messages
+
+require 'midi-message/short_message'
+require 'midi-message/channel_message'
+require 'midi-message/constant'
+require 'midi-message/context'
+require 'midi-message/note_message'
+require 'midi-message/parser'
+require 'midi-message/system_message'
+require 'midi-message/system_exclusive'
+require 'midi-message/type_conversion'
+
+# message processors
+
+# modules
+require "midi-message/process/processor"
+
+# classes
+require "midi-message/process/filter"
+require "midi-message/process/limit"
+require "midi-message/process/transpose"