midi-message 0.0.1-i686-linux

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2010-2011 Ari Russo
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.rdoc

@@ -0,0 +1,24 @@
+= midi-messages
+
+== Summary
+
+MIDI Messages in Ruby
+
+== Features
+
+* Objectification of the MIDI spec
+* YAML Dictionary of MIDI constants
+	
+== Install
+
+* gem install midi-message (*not yet available)
+
+== Author
+
+* {Ari Russo}[http://github.com/arirusso] <ari.russo at gmail.com>
+
+== License
+
+Apache 2.0, See the file LICENSE
+
+Copyright (c) 2011 Ari Russo

data/lib/midi-message/channel_message.rb

@@ -0,0 +1,203 @@
+#!/usr/bin/env ruby
+#
+module MIDIMessage
+
+    # common behavior amongst Channel Message types
+    module ChannelMessageBehavior
+
+      attr_reader :data,
+                  :name,
+                  :status
+                  
+      def initialize_channel_message(status_nibble_1, status_nibble_2, data_byte_1, data_byte_2 = 0)
+        @status = [status_nibble_1, status_nibble_2]
+        @data = [data_byte_1]
+        @data[1] = data_byte_2 if self.class::second_data_byte?
+        initialize_shortcuts
+        initialize_simple_message(status_nibble_1, status_nibble_2)
+      end
+
+      def to_a
+        db2 = self.class::second_data_byte? ? @data[1] : nil
+        [@status[0] + @status[1], @data[0], db2].compact
+      end
+      alias_method :to_byte_array, :to_a
+      alias_method :to_bytes, :to_a
+
+      def to_hex_s
+        to_a.join
+      end
+      alias_method :hex, :to_hex_s
+
+      def initialize(*a)
+        initialize_channel_message(self.class::TypeId, *a)
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def type_for_status
+          0 + (const_get(:TypeId) << 4)
+        end
+
+        def type_id(id)
+          const_set(:TypeId, id)
+        end
+
+        def schema(*args)
+          self.send(:const_set, :Shortcuts, args)
+          const_set(:NumDataBytes, args.length-1)
+        end
+        alias_method :layout, :schema
+
+        def second_data_byte?
+          num = const_get(:NumDataBytes)
+          !num.nil? && num > 1
+        end
+
+      end
+
+      def initialize_shortcuts
+         props = [
+           { :name => :status, :index => 1 }, 
+           { :name => :data, :index => 0 },
+           { :name => :data, :index => 1 }
+         ]
+	       shortcuts = self.class.send(:const_get, :Shortcuts)
+	       shortcuts.each_with_index do |prop,i|
+           self.class.send(:attr_reader, prop)
+	         self.class.send(:define_method, "#{prop}=") do |val|
+	           send(:instance_variable_set, "@#{prop.to_s}", val)
+             send(props[i][:name])[props[i][:index]] = val
+	         end
+           instance_variable_set("@#{prop}", send(props[i][:name])[props[i][:index]])
+         end
+
+      end
+
+    end
+
+    # use this if you want to instantiate a raw channel message
+    #
+    # example = ChannelMessage.new(0x9, 0x0, 0x40, 0x57) # creates a raw note-on message
+    #
+    class ChannelMessage
+
+      include SimpleMessageBehavior
+      include ChannelMessageBehavior
+
+      display_name 'Channel Message'
+      
+      def initialize(*a)
+        initialize_channel_message(*a)
+      end
+
+    end
+
+    #
+    # MIDI Channel Aftertouch message
+    #
+    class ChannelAftertouch
+
+      include SimpleMessageBehavior
+      include ChannelMessageBehavior
+
+      schema :channel, :value
+      type_id 0xD
+      display_name 'Channel Aftertouch'
+
+    end
+
+    #
+    # MIDI Control Change message
+    #
+    class ControlChange
+
+      include SimpleMessageBehavior
+      include ChannelMessageBehavior
+
+      schema :channel, :number, :value
+      type_id 0xB
+      display_name 'Control Change'
+      identifier :number
+
+    end
+
+    #
+    # MIDI Note-Off message
+    #
+    class NoteOff
+
+      include SimpleMessageBehavior
+      include ChannelMessageBehavior
+
+      schema :channel, :note, :velocity
+      type_id 0x8
+      display_name 'Note Off'
+      use_constants 'Note'
+      identifier :note
+
+    end
+
+    #
+    # MIDI Note-On message
+    #
+    class NoteOn
+
+      include SimpleMessageBehavior
+      include ChannelMessageBehavior
+
+      schema :channel, :note, :velocity
+      type_id 0x9
+      display_name 'Note On'
+      use_constants 'Note'
+      identifier :note
+
+    end
+
+    #
+    # MIDI Pitch Bend message
+    #
+    class PitchBend
+
+      include SimpleMessageBehavior
+      include ChannelMessageBehavior
+
+      schema :channel, :low, :high
+      type_id 0xE
+      DisplayName = 'Pitch Bend'
+
+    end
+
+    #
+    # MIDI Polyphonic (note specific) Aftertouch message
+    #
+    class PolyphonicAftertouch
+
+      include SimpleMessageBehavior
+      include ChannelMessageBehavior
+
+      schema :channel, :note, :value
+      type_id 0xA
+      DisplayName = 'Polyphonic Aftertouch'
+
+    end
+
+    #
+    # MIDI Program Change message
+    #
+    class ProgramChange
+
+      include SimpleMessageBehavior
+      include ChannelMessageBehavior
+
+      schema :channel, :program
+      type_id 0xC
+      DisplayName = 'Program Change'
+
+    end
+    
+end

data/lib/midi-message/constant.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+#
+require 'yaml'
+require 'singleton'
+
+module MIDIMessage
+
+  # MIDI Constants
+  class Constant
+
+    include Singleton
+
+    def initialize
+      # cache the constants data
+      require 'midi-message/constants'
+      @dict = YAML::load(@@data)
+    end
+
+    def [](key)
+      @dict[key]
+    end
+
+    def self.[](key)
+      instance[key]
+    end
+
+  end
+
+end

data/lib/midi-message/constants.rb

@@ -0,0 +1,103 @@
+# better way to do this?
+@@data = %q{
+
+Control Change:
+  Bank Select: 0
+  Modulation Wheel: 1
+  Breath Controller: 2
+  Foot Controller: 4
+  Portamento Time: 5
+  Data Entry MSB: 6
+  Channel Volume: 7
+  Balance: 8
+  Pan: 10
+  Expression Controller: 11
+  General Purpose Controllers: 16
+  General Purpose Controllers: 17
+  General Purpose Controllers: 18
+  General Purpose Controllers: 19
+  LSB for controller 0: 32
+  LSB for controller 1: 33
+  LSB for controller 2: 34
+  LSB for controller 3: 35
+  LSB for controller 4: 36
+  LSB for controller 5: 37
+  LSB for controller 6: 38
+  LSB for controller 7: 39
+  LSB for controller 8: 40
+  LSB for controller 9: 41
+  LSB for controller 10: 42
+  LSB for controller 11: 43
+  LSB for controller 12: 44
+  LSB for controller 13: 45
+  LSB for controller 14: 46
+  LSB for controller 15: 47
+  LSB for controller 16: 48
+  LSB for controller 17: 49
+  LSB for controller 18: 50
+  LSB for controller 19: 51
+  LSB for controller 20: 52
+  LSB for controller 21: 53
+  LSB for controller 22: 54
+  LSB for controller 23: 55
+  LSB for controller 24: 56
+  LSB for controller 25: 57
+  LSB for controller 26: 58
+  LSB for controller 27: 59
+  LSB for controller 28: 60
+  LSB for controller 29: 61
+  LSB for controller 30: 62
+  LSB for controller 31: 63
+  Hold Pedal: 64
+  Portamento: 65
+
+Control Mode:
+  All Sound Off: 120
+  All Controllers Off: 121
+  Local Keyboard Toggle: 122
+  All Notes Off: 123
+  Omni Mode Off: 124
+  Omni Mode On: 125
+  Mono: 126
+  Poly: 127
+
+System Realtime:
+  Start: 0xFA
+  Clock: 0xF8
+  Continue: 0xFB
+  Stop: 0xFC
+  Reset: 0xFF
+  ActiveSense: 0xFE
+
+Manufacturers:
+
+  SequentialCircuits: 1
+  BigBriar: 2
+  Octave: 3
+  Moog: 4
+  Passport: 5
+  Lexicon: 6
+
+  PAIA: 0x11
+  Simmons: 0x12
+  GentleElectric: 0x13
+  Fairlight: 0x14
+  BonTempi: 0x20
+  SIEL: 0x21
+  SyntheAxe: 0x23
+
+  Kawai: 0x40
+  Roland: 0x41
+  Korg: 0x42
+  Yamaha: 0x43
+  Casio: 0x44
+  Akai: 0x47
+
+  Emagic: [0x00, 0x20, 0x31]
+  Behringer: [0x00, 0x20, 0x32]
+
+Note:
+
+  C3: 64
+
+}

data/lib/midi-message/parser.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+#
+module MIDIMessage
+
+    # very simple parsing
+    # for more advanced parsing check out {nibbler}[http://github.com/arirusso/nibbler]
+    class Parser
+      
+      # can take either a hex string eg Parser.new("904040")
+      # or bytes eg Parser.new(0x90, 0x40, 0x40)
+      # or an array of bytes eg Parser.new([0x90, 0x40, 0x40])
+      def initialize(*a)
+        @data = case a.first
+          when Array then a.first
+          when Numeric then a 
+          when String then str_to_bytes(a.first)
+        end
+      end
+      
+      def parse
+        first_nibble = @data.first >> 4
+        second_nibble = @data.first >> 8
+        case first_nibble
+          when 0x8 then NoteOff.new(second_nibble, @data[1], @data[2])
+          when 0x9 then NoteOn.new(second_nibble, @data[1], @data[2])
+          when 0xA then PolyphonicAftertouch.new(second_nibble, @data[1], @data[2])
+          when 0xB then ControlChange.new(second_nibble, @data[1], @data[2])
+          when 0xC then ProgramChange.new(second_nibble, @data[1])
+          when 0xD then ChannelAftertouch.new(second_nibble, @data[1])
+          when 0xE then PitchBend.new(second_nibble, @data[1], @data[2])
+          when 0xF then case second_nibble
+            when 0x0 then SystemExclusive.new(*@data)
+            when 0x1..0x6 then SystemCommon.new(second_nibble, @data[1], @data[2])
+            when 0x8..0xF then SystemRealtime.new(second_nibble)
+            else nil
+          end
+          else nil
+        end
+      end
+    
+    end
+    
+    def self.parse(*a)
+      Parser.new(*a).parse
+    end
+
+end

data/lib/midi-message/simple_message.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+#
+module MIDIMessage
+
+    # common behavior amongst all Message types
+    module SimpleMessageBehavior
+
+      attr_reader :name,
+                  :status,
+                  :verbose_name
+
+      def initialize_simple_message(status_nibble_1, status_nibble_2)
+	      @status = [status_nibble_1, status_nibble_2]
+        group_name = self.class.const_get(:DisplayName)
+        group_name_alias = self.class.const_get(:UseConstants) rescue nil
+        val = self.send(self.class.const_get(:Identifier)) rescue @status[1]
+        group = Constant[group_name] || (group_name_alias.nil? ? nil : Constant[group_name_alias])
+        unless group.nil?
+          const = group.find { |k,v| k if v.eql?(val) }
+          unless const.nil?
+            @name = const.first
+            @verbose_name = "#{self.class::DisplayName}: #{const.first}"
+          end
+        end
+      end
+
+      def to_hex_s
+        to_a.join
+      end
+      alias_method :hex, :to_hex_s
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def display_name(name)
+          const_set(:DisplayName, name)
+        end
+
+        def use_constants(name)
+          const_set(:UseConstants, name)
+        end
+
+        def identifier(name)
+          const_set(:Identifier, name)
+        end
+
+      end
+
+    end
+
+end

data/lib/midi-message/system_exclusive.rb

@@ -0,0 +1,158 @@
+#!/usr/bin/env ruby
+#
+#
+module MIDIMessage
+
+  module SystemExclusive
+
+    # 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, :device_id => device_id)
+      msg_class.new(address, value, :checksum => checksum, :node => node)
+    end
+  
+    # basic SysEx data that a message class will contain
+    module Data
+    
+      attr_reader :address,
+                  :checksum,
+                  :device
+
+      StartByte = 0xF0
+      EndByte = 0xF7
+    
+      # an array of message parts.  multiple byte parts will be represented as an array of bytes
+      def to_a
+        array
+      end
+    
+      # a flat array of message bytes
+      def to_byte_array
+        array.flatten
+      end
+    
+      private
+    
+      def address_to_i
+        address.inject { |a,b| a + b }
+      end
+    
+      def value_to_i
+        value.kind_of?(Array) ? value.inject { |a,b| a + b } : value
+      end
+    
+      def initialize_sysex(address, options = {})
+        @node = options[:node]
+        @checksum = options[:checksum]
+        @address = address
+      end
+
+      def array
+        # this may need to be cached when properties are updated
+        # might be worth benchmarking
+        @checksum = (128 - (address_to_i + value_to_i).divmod(128)[1])
+        [
+          StartByte,
+          @node.manufacturer,
+          (@device_id || @node.device_id),
+          @node.model_id,
+          status_byte,
+          address,
+          value,
+          @checksum,
+          EndByte
+        ]
+      end
+    
+    end
+  
+    # A SysEx command message
+    #
+    class Command
+    
+      include Data
+    
+      attr_reader :data
+
+      StatusByte = 0x12
+    
+      def initialize(address, data, options = {})
+        @data = data
+        initialize_sysex(address, options)
+      end
+    
+      def value
+        @data
+      end
+    
+      def data=(val)
+        @data = val
+        update_byte_array
+      end
+    
+    end
+
+    #
+    # The SystemExclusive::Node represents a hardware synthesizer or other MIDI device that a message
+    # is being sent to or received from.
+    #
+    class Node
+    
+      attr_accessor :device_id # (Not to be confused with any kind of Device class in this library)
+      attr_reader :manufacturer, :model_id
+    
+      def initialize(manufacturer, model_id, options = {})
+        @device_id = options[:device_id]
+        @model_id = model_id
+        @manufacturer = manufacturer
+      end
+    
+      def message(*a)
+        a << { :node => self }
+        Command.new(*a)
+      end
+    
+    end
+  
+    # A SysEx request message
+    #
+    class Request
+    
+      include Data
+    
+      attr_accessor :size
+      alias_method :value, :size
+
+      StatusByte = 0x11
+    
+      def initialize(address, size, options = {})
+        @size = size
+        initialize_sysex(address, options = {})
+      end
+    
+    end
+  
+  end
+
+end

data/lib/midi-message/system_message.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+#
+module MIDIMessage
+  
+  #
+  # MIDI System-Common message
+  #
+  class SystemCommon
+
+    include SimpleMessageBehavior
+    display_name 'System Common'
+
+    attr_reader :status,
+                :data
+    
+    def initialize(status_nibble_2, data_byte_1 = nil, data_byte_2 = nil)
+      @data = [data_byte_1, data_byte_2]
+      initialize_simple_message(0xF, status_nibble_2)
+    end
+    
+  end  
+  
+  #
+  # MIDI System-Realtime message
+  #
+  class SystemRealtime
+
+    include SimpleMessageBehavior
+    display_name 'System Realtime'
+
+    attr_reader :status
+    
+    def initialize(id)
+      initialize_simple_message(0xF, id)
+    end
+
+    def id
+      @status[1]
+    end
+
+  end
+  
+end

data/lib/midi-message.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# MIDI Messages in Ruby
+#
+module MIDIMessage
+  
+  VERSION = "0.0.1"
+ 
+end
+
+require 'midi-message/simple_message'
+require 'midi-message/channel_message'
+require 'midi-message/constant'
+require 'midi-message/parser'
+require 'midi-message/system_message'
+require 'midi-message/system_exclusive'

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: midi-message
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: i686-linux
+authors: 
+- Ari Russo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-29 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: MIDI Messages, objectified in Ruby.
+email: 
+- ari.russo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/midi-message.rb
+- lib/midi-message/system_exclusive.rb
+- lib/midi-message/channel_message.rb
+- lib/midi-message/simple_message.rb
+- lib/midi-message/constants.rb
+- lib/midi-message/parser.rb
+- lib/midi-message/system_message.rb
+- lib/midi-message/constant.rb
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/arirusso/midi-message
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: midi-message
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: MIDI Messages in Ruby.
+test_files: []
+