midi-events 0.5.0

data/lib/midi-events/note_message.rb

@@ -0,0 +1,40 @@
+module MIDIEvents
+
+  # Common Note Message Behavior
+  module NoteMessage
+
+    def self.included(base)
+      base.send(:include, ChannelMessage)
+    end
+
+    # The octave number of the note
+    # @return [Fixnum]
+    def octave
+      (note / 12) - 1
+    end
+    alias_method :oct, :octave
+
+    # Set the octave number of the note
+    # @param [Fixnum] value
+    # @return [NoteMessage] self
+    def octave=(value)
+      self.note = ((value + 1) * 12) + abs_note
+      self
+    end
+    alias_method :oct=, :octave=
+
+    # How many half-steps is this note above the closest C
+    # @return [Fixnum]
+    def abs_note
+      note - ((note / 12) * 12)
+    end
+
+    # The name of the note without its octave e.g. F#
+    # @return [String]
+    def note_name
+      name.split(/-?\d\z/).first unless name.nil?
+    end
+
+  end
+
+end

data/lib/midi-events/system_exclusive.rb

@@ -0,0 +1,244 @@
+module MIDIEvents
+
+  # MIDI System-Exclusive Messages (SysEx)
+  module SystemExclusive
+    include MIDIEvents # this enables ..kind_of?(MIDIMessage)
+
+    def self.included(base)
+      base.send(:include, InstanceMethods)
+    end
+
+    # Common SysEx data that a message class will contain
+    module InstanceMethods
+      attr_accessor :node
+      attr_reader :address, :checksum
+
+      # an array of message parts.  multiple byte parts will be represented as an array of bytes
+      def to_a(options = {})
+        omit = options[:omit] || []
+        node = @node.to_a(options) unless @node.nil? || omit.include?(:node)
+        # this may need to be cached when properties are updated
+        # might be worth benchmarking
+        [
+          start_byte,
+          node,
+          (type_byte unless omit.include?(:type)),
+          [address].compact.flatten,
+          [value].compact.flatten,
+          (checksum unless omit.include?(:checksum)),
+          end_byte
+        ].compact
+      end
+
+      # a flat array of message bytes
+      def to_numeric_byte_array(options = {})
+        to_a(options).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
+        strings = to_bytes.map do |byte|
+          string = byte.to_s(16)
+          string = "0#{string}" if string.length == 1
+          string
+        end
+        strings.join.upcase
+      end
+      alias_method :to_bytestr, :to_hex_s
+
+      def name
+        SystemExclusive::DISPLAY_NAME
+      end
+      alias_method :verbose_name, :name
+
+      def start_byte
+        SystemExclusive::DELIMITER[:start]
+      end
+
+      def end_byte
+        SystemExclusive::DELIMITER[:finish]
+      end
+
+      def type_byte
+        self.class::TYPE
+      end
+
+      # alternate method from
+      # http://www.2writers.com/eddie/TutSysEx.htm
+      def checksum
+        sum = (address + [value].flatten).inject(&:+)
+        mod = sum.divmod(128)[1]
+        128 - mod
+      end
+
+      private
+
+      def initialize_sysex(address, options = {})
+        @node = options[:node]
+        @checksum = options[:checksum]
+        @address = address
+      end
+
+    end
+
+    # A SysEx message with no implied type
+    #
+    class Message
+      include InstanceMethods
+
+      attr_accessor :data
+
+      def initialize(data, options = {})
+        @data = if data.kind_of?(Array) && data.length == 1
+          data.first
+        else
+          data
+        end
+        initialize_sysex(nil, options)
+      end
+
+      # an array of message parts.  multiple byte parts will be represented as an array of bytes
+      def to_a(options = {})
+        omit = options[:omit] || []
+        node = @node.to_a(options) unless @node.nil? || omit.include?(:node)
+        # this may need to be cached when properties are updated
+        # might be worth benchmarking
+        [
+          start_byte,
+          node,
+          @data,
+          end_byte
+        ].compact
+      end
+
+      def ==(other_message)
+        self.class == other_message.class &&
+          to_a == other_message.to_a
+      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 = get_manufacturer_id(manufacturer)
+      end
+
+      def to_a(options = {})
+        omit = options[:omit] || []
+        properties = [:manufacturer, :device, :model].map do |property|
+          unless omit.include?(property) || omit.include?("#{property.to_s}_id")
+            instance_variable_get("@#{property.to_s}_id")
+          end
+        end
+        properties.compact
+      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
+
+      private
+
+      def get_manufacturer_id(manufacturer)
+        if manufacturer.kind_of?(Numeric)
+          manufacturer
+        else
+          const = Constant.find("Manufacturer", manufacturer)
+          const.value
+        end
+      end
+
+    end
+
+    module Builder
+
+      extend self
+
+      # Convert raw MIDI data to a SysEx message object
+      def build(*bytes)
+        if is_sysex?(bytes)
+
+          # if the 4th byte isn't status, we will just make this a Message object
+          #   -- this may need some tweaking
+          message_class = get_message_class(bytes)
+
+          if message_class.nil?
+            Message.new(bytes)
+          else
+            build_typed_message(message_class, bytes)
+          end
+        end
+
+      end
+
+      private
+
+      def get_message_class(bytes)
+        [Request, Command].find { |klass| klass::TYPE == bytes[3] }
+      end
+
+      def is_sysex?(bytes)
+        bytes.shift == SystemExclusive::DELIMITER[:start] &&
+          bytes.pop == SystemExclusive::DELIMITER[:finish]
+      end
+
+      # Build a SysEx message object of the given type using the given bytes
+      def build_typed_message(message_class, bytes)
+        bytes = bytes.dup
+        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]
+
+        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)
+        message_class.new(address, value, :checksum => checksum, :node => node)
+      end
+
+    end
+
+    # Convert raw MIDI data to a SysEx message object
+    # Shortcut to Builder.build
+    def self.new(*bytes)
+      Builder.build(*bytes)
+    end
+
+  end
+
+end

data/lib/midi-events/system_message.rb

@@ -0,0 +1,19 @@
+module MIDIEvents
+  # Common MIDI system message behavior
+  module SystemMessage
+    STATUS = 0xF
+
+    def self.included(base)
+      base.send(:include, Message)
+    end
+
+    # In the case of something like SystemCommon.new(0xF2, 0x00, 0x08), the first nibble F is redundant because
+    # all system messages start with 0xF and it can be assumed.
+    # However, the this method looks to see if this has occurred and strips the redundancy
+    # @param [Fixnum] byte The byte to strip of a redundant 0xF
+    # @return [Fixnum] The remaining nibble
+    def strip_redundant_nibble(byte)
+      byte > STATUS ? (byte & 0x0F) : byte
+    end
+  end
+end

data/lib/midi-events/type_conversion.rb

@@ -0,0 +1,79 @@
+module MIDIEvents
+ 
+  # Helper for converting nibbles and bytes
+  module TypeConversion
+    
+    extend self
+
+    # Convert an array of hex nibbles to an array of numeric bytes
+    # eg ["9", "0", "4", "0"] to [0x90, 0x40]
+    #
+    # @param [Array<String>] An array of hex nibbles eg ["9", "0", "4", "0"]
+    # @return [Array<Fixnum] An array of numeric bytes eg [0x90, 0x40]
+    def hex_chars_to_numeric_byte_array(nibbles)
+      nibbles = nibbles.dup # Don't mess with the input
+      # 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 string to an array of numeric bytes
+    # eg. "904040" to [0x90, 0x40, 0x40]
+    # @param [String] string A string representing hex digits eg "904040"
+    # @return [Array<Fixnum>] An array of numeric bytes eg [0x90, 0x40, 0x40]
+    def hex_string_to_numeric_byte_array(string)
+      string = string.dup
+      bytes = []
+      until string.length == 0
+        bytes << string.slice!(0, 2).hex
+      end
+      bytes
+    end
+    
+    # Convert a string of hex digits to an array of nibbles
+    # eg. "904040" to ["9", "0", "4", "0", "4", "0"]
+    # @param [String] string A string representing hex digits eg "904040"
+    # @return [Array<String>] An array of hex nibble chars eg ["9", "0", "4", "0", "4", "0"]
+    def hex_str_to_hex_chars(string)
+      string.split(//)    
+    end
+    
+    # Convert an array of numeric bytes to a string of hex digits
+    # eg. [0x90, 0x40, 0x40] to "904040"
+    # @param [Array<Fixnum>] bytes An array of numeric bytes eg [0x90, 0x40, 0x40]
+    # @return [String] A string representing hex digits eg "904040"
+    def numeric_byte_array_to_hex_string(bytes)
+      string_bytes = bytes.map do |byte| 
+        string = byte.to_s(16)
+        string = "0#{string}" if string.length == 1
+        string
+      end
+      string_bytes.join.upcase
+    end
+    
+    # Convert a numeric byte to hex chars
+    # eg 0x90 to ["9", "0"]
+    # @param [Fixnum] num A numeric byte eg 0x90
+    # @return [Array<String>] An array of hex nibble chars eg ["9", "0"]
+    def numeric_byte_to_hex_chars(num)
+      nibbles = numeric_byte_to_nibbles(num)
+      nibbles.map { |n| n.to_s(16) }      
+    end
+
+    # Convert a numeric byte to nibbles
+    # eg 0x90 to [0x9, 0x0]
+    # @param [Fixnum] num A numeric byte eg 0x90
+    # @return [Array<Fixnum>] An array of nibbles eg [0x9, 0x0]
+    def numeric_byte_to_nibbles(num)
+      [((num & 0xF0) >> 4), (num & 0x0F)]
+    end
+
+  end
+  
+end

data/lib/midi-events.rb

@@ -0,0 +1,27 @@
+#
+# Ruby MIDI message objects
+#
+# (c)2021 Javier Sánchez Yeste for the modifications, licensed under LGPL 3.0 License
+# (c)2011-2015 Ari Russo for original MIDI Message library, licensed under Apache 2.0 License
+#
+
+# Libs
+require 'forwardable'
+require 'yaml'
+
+# Modules
+require 'midi-events/constant'
+require 'midi-events/message'
+require 'midi-events/channel_message'
+require 'midi-events/note_message'
+require 'midi-events/system_exclusive'
+require 'midi-events/system_message'
+require 'midi-events/type_conversion'
+
+# Classes
+require 'midi-events/context'
+require 'midi-events/messages'
+
+module MIDIEvents
+  VERSION = '0.5.0'.freeze
+end