midi-nibbler 0.0.3

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,106 @@
+= nibbler
+
+{cat on arp}[http://images.treetrouble.net/images/dog_with_synth.jpg]
+
+Parse MIDI Messages
+
+== Requirements
+
+* {midi-message}[http://github.com/arirusso/midi-message]  
+	
+== Install
+
+  gem install midi-nibbler
+
+== Usage
+
+  require 'nibbler'
+  
+  nibbler = Nibbler.new
+
+Enter a message piece by piece
+  
+  p nibbler.parse("90")
+  nil
+
+  p nibbler.parse("40")
+  nil
+
+  p nibbler.parse("40")
+  # #<MIDIMessage::NoteOn:0x98c9818 
+  #  @channel=0, 
+  #  @data=[64, 100], 
+  #  @name="C3", 
+  #  @note=64, 
+  #  @status=[9, 0], 
+  #  @velocity=100, 
+  #  @verbose_name="Note On: C3">
+  
+Enter a message all at once
+  
+  p nibbler.parse("904040")
+  
+  # #<MIDIMessage::NoteOn:0x98c9818 
+  #  @channel=0, 
+  #  @data=[64, 100], 
+  #  @name="C3", 
+  #  @note=64, 
+  #  @status=[9, 0], 
+  #  @velocity=100, 
+  #  @verbose_name="Note On: C3">
+  
+Use bytes
+  
+  p nibbler.parse(0x90, 0x40, 0x40)
+  #<MIDIMessage::NoteOn:0x98c9818 ...>
+    
+You can use nibbles in string format
+  
+  p nibbler.parse("9", "0", "4", "0", "4", "0")
+  #<MIDIMessage::NoteOn:0x98c9818 ...>
+  
+Interchange the different types
+  
+  p nibbler.parse("9", "0", 0x40, 64)
+  #<MIDIMessage::NoteOn:0x98c9818 ...>
+  
+Use running status
+
+  p nibbler.parse(0x40, 64)
+  #<MIDIMessage::NoteOn:0x98c9818 ...>
+  
+Look at the messages we've parsed
+  
+  p nibbler.messages
+  [#<MIDIMessage::NoteOn:0x98c9804 ...>
+   #<MIDIMessage::NoteOn:0x98c9811 ...>]
+  
+Add an incomplete message
+  
+  p nibbler.parse("9")
+  p nibbler.parse("40")
+  
+See progress
+  
+  p nibbler.buffer
+  ["9", "4", "0"]
+  
+  p nibbler.buffer_hex
+  "940"
+  
+Nibbler defaults to generate {midi-message}[http://github.com/arirusso/midi-message] objects, but it is also possible to use {midilib}[https://github.com/jimm/midilib] 
+
+  Nibbler.new(:message_lib => :midilib)
+  
+  p nibbler.parse("9", "0", 0x40, "40")
+  "0: ch 00 on 40 40"
+
+== 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/nibbler/hex_char_array_filter.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+#
+module Nibbler  
+  
+  # Turns various types of input in to an array of hex digit chars
+  class HexCharArrayFilter
+       
+    # returns an array of hex string nibbles
+    def process(*a)
+      a.flatten!
+      buf = []
+      a.each do |thing|
+        buf += case thing
+          when Array then thing.map { |arr| to_nibbles(*arr) }.inject { |a,b| a + b }
+          when String then TypeConversion.hex_str_to_hex_chars(filter_string(thing))
+          when Numeric then TypeConversion.numeric_byte_to_hex_chars(filter_numeric(thing))
+        end
+      end
+      buf.compact.map { |n| n.upcase } 
+    end
+    
+    private
+    
+    # limit <em>num</em> to bytes usable in MIDI ie values (0..240)
+    # returns nil if the byte is outside of that range
+    def filter_numeric(num)
+      (0x00..0xFF).include?(num) ? num : nil
+    end
+    
+    # get rid of non-hex string characters
+    def filter_string(str)
+      str.gsub(/[^0-9a-fA-F]/, '').upcase
+    end
+  
+  end
+
+end

data/lib/nibbler/midi-message_factory.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+#
+module Nibbler
+
+  # factory for constructing messages with {midi-message}(http://github.com/arirusso/midi-message)
+  class MIDIMessageFactory
+    
+    include MIDIMessage
+    
+    def note_off(second_nibble, data_byte_1, data_byte_2)
+      NoteOff.new(second_nibble, data_byte_1, data_byte_2)
+    end
+    
+    def note_on(second_nibble, data_byte_1, data_byte_2)
+      NoteOn.new(second_nibble, data_byte_1, data_byte_2)
+    end
+    
+    def polyphonic_aftertouch(second_nibble, data_byte_1, data_byte_2)
+      PolyphonicAftertouch.new(second_nibble, data_byte_1, data_byte_2)
+    end
+      
+    def control_change(second_nibble, data_byte_1, data_byte_2)
+      ControlChange.new(second_nibble, data_byte_1, data_byte_2)
+    end
+    
+    def program_change(second_nibble, data_byte)
+      ProgramChange.new(second_nibble, data_byte)
+    end
+    
+    def channel_aftertouch(second_nibble, data_byte)
+      ChannelAftertouch.new(second_nibble, data_byte)
+    end
+    
+    def pitch_bend(second_nibble, data_byte_1, data_byte_2)
+      PitchBend.new(second_nibble, data_byte_1, data_byte_2)
+    end
+    
+    def system_exclusive(*a)
+      SystemExclusive.new(*a)
+    end
+    
+    def system_common(second_nibble, data_byte_1 = nil, data_byte_2 = nil)
+      SystemCommon.new(second_nibble, data_byte_1, data_byte_2)
+    end
+    
+    def system_realtime(second_nibble)
+      SystemRealtime.new(second_nibble)
+    end
+    
+        
+  
+  end
+
+end

data/lib/nibbler/midilib_factory.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+#
+module Nibbler
+
+  # factory for constructing messages with {midilib}(https://github.com/jimm/midilib)
+  # midilib is copyright © 2003-2010 Jim Menard
+  class MidilibFactory
+    
+    include MIDI
+    
+    def note_off(second_nibble, data_byte_1, data_byte_2)
+      NoteOff.new(second_nibble, data_byte_1, data_byte_2)
+    end
+    
+    def note_on(second_nibble, data_byte_1, data_byte_2)
+      NoteOn.new(second_nibble, data_byte_1, data_byte_2)
+    end
+    
+    def polyphonic_aftertouch(second_nibble, data_byte_1, data_byte_2)
+      PolyPressure.new(second_nibble, data_byte_1, data_byte_2)
+    end
+      
+    def control_change(second_nibble, data_byte_1, data_byte_2)
+      Controller.new(second_nibble, data_byte_1, data_byte_2)
+    end
+    
+    def program_change(second_nibble, data_byte)
+      ProgramChange.new(second_nibble, data_byte)
+    end
+    
+    def channel_aftertouch(second_nibble, data_byte)
+      ChannelPressure.new(second_nibble, data_byte)
+    end
+    
+    def pitch_bend(second_nibble, data_byte_1, data_byte_2)
+      # to-do handle the midilib lsb/msb
+      # right now the second data byte is being thrown away
+      PitchBend.new(second_nibble, data_byte_1, data_byte_2)
+    end
+    
+    def system_exclusive(*a)
+      SystemExclusive.new(a)
+    end
+    
+    def system_common(second_nibble, data_byte_1 = nil, data_byte_2 = nil)
+      case second_nibble
+        when 0x2 then SongPointer.new(data_byte_1) # similar issue to pitch bend here
+        when 0x3 then SongSelect.new(data_byte_1)
+        when 0x6 then TuneRequest.new
+      end      
+    end
+    
+    def system_realtime(second_nibble)
+      case second_nibble
+        when 0x8 then Clock.new
+        when 0xA then Start.new
+        when 0xB then Continue.new
+        when 0xC then Stop.new
+        when 0xE then ActiveSense.new
+        when 0xF then SystemReset.new
+      end      
+    end  
+    
+  end
+
+end

data/lib/nibbler/nibbler.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+#
+module Nibbler
+ 
+  # this is the entry point to the app
+  class Nibbler
+
+    extend Forwardable
+
+    attr_reader :messages,
+                :processed,
+                :rejected
+    
+    # this class holds on to all output except for the buffer because the data in the buffer
+    # is the only data that's relevant between calls of Parser.process 
+    def_delegators :@parser, :buffer            
+    def_delegator :clear_buffer, :buffer, :clear
+    def_delegator :clear_processed, :processed, :clear
+    def_delegator :clear_rejected, :rejected, :clear
+    def_delegator :clear_messages, :messages, :clear
+
+    def initialize(options = {}, &block)
+      @processed, @rejected, @messages = [], [], []
+      @parser = Parser.new(options)    
+      @typefilter = HexCharArrayFilter.new
+      block.call unless block.nil?
+    end
+    
+    def all_messages
+      @messages | @fragmented_messages
+    end
+    
+    def buffer_hex
+      buffer.join
+    end
+
+    def clear_buffer
+      buffer.clear
+    end
+
+    def clear_messages
+      @messages.clear
+    end
+
+    def parse(*a)
+      queue = @typefilter.process(a)
+      result = @parser.process(queue)
+      @messages += result[:messages]
+      @processed += result[:processed]
+      @rejected += result[:rejected]
+      #@buffer = result[:remaining]
+      # return type
+      # 0 messages: nil
+      # 1 message: the message
+      # >1 message: an array of messages
+      # might make sense to make this an array no matter what...
+      if result[:messages].length < 2 
+        (result[:messages].empty? ? nil : result[:messages][0])
+      else 
+        result[:messages]
+      end
+    end
+    
+  end
+  
+end

data/lib/nibbler/parser.rb

@@ -0,0 +1,154 @@
+#!/usr/bin/env ruby
+#
+module Nibbler
+ 
+
+  # this is where messages go
+  class Parser
+    
+    attr_reader :buffer
+    
+    def initialize(options = {})
+      @running_status = nil
+      @buffer = []
+      @iterator = 0
+      
+      case options[:message_lib]
+        when :midilib then    
+          require 'midilib'
+          require 'nibbler/midilib_factory'
+          @message_factory = MidilibFactory.new
+        else    
+          require 'midi-message'    
+          require 'nibbler/midi-message_factory'    
+          @message_factory = MIDIMessageFactory.new    
+      end 
+    end
+
+    def process(nibbles)
+      output = { 
+        :messages => [], 
+        :processed => [], 
+        :rejected => [] 
+      }          
+      @iterator = 0      
+      @buffer += nibbles  
+      while @iterator <= (@buffer.length - 1)
+        # iterate through nibbles until a status message is found        
+        # see if there really is a message there
+        populate_current
+        # current is the current piece of the buffer we're dealing with
+        processed = nibbles_to_message
+        unless processed[:message].nil?
+          # if it's a real message, reject previous nibbles
+          output[:rejected] += @buffer.slice(0, @iterator)          
+          # and record it          
+          @buffer = @current # current now has the remaining nibbles for next pass
+          @current = nil # reset current
+          @iterator = 0 # reset iterator
+          output[:messages] << processed[:message]
+          output[:processed] += processed[:processed]          
+        else
+          @running_status = nil
+          @iterator += 1
+        end         
+      end
+      output
+    end
+    
+    def nibbles_to_message
+      output = { 
+        :message => nil, 
+        :processed => [], 
+        :remaining => nil 
+      } 
+      return output if @current.length < 2
+      first = @current[0].hex
+      second = @current[1].hex
+      
+      output[:message], output[:processed] = *case first
+        when 0x8 then lookahead(6) { |status_2, bytes| @message_factory.note_off(status_2, bytes[1], bytes[2]) }
+        when 0x9 then lookahead(6) { |status_2, bytes| @message_factory.note_on(status_2, bytes[1], bytes[2]) }
+        when 0xA then lookahead(6) { |status_2, bytes| @message_factory.polyphonic_aftertouch(status_2, bytes[1], bytes[2]) }
+        when 0xB then lookahead(6) { |status_2, bytes| @message_factory.control_change(status_2, bytes[1], bytes[2]) }
+        when 0xC then lookahead(4) { |status_2, bytes| @message_factory.program_change(status_2, bytes[1]) }
+        when 0xD then lookahead(4) { |status_2, bytes| @message_factory.channel_aftertouch(status_2, bytes[1]) }
+        when 0xE then lookahead(6) { |status_2, bytes| @message_factory.pitch_bend(status_2, bytes[1], bytes[2]) }
+        when 0xF then case second
+          when 0x0 then lookahead_sysex { |bytes| @message_factory.system_exclusive(*bytes) }
+          when 0x1..0x6 then lookahead(6, :recursive => true) { |status_2, bytes| @message_factory.system_common(status_2, bytes[1], bytes[2]) }
+          when 0x8..0xF then lookahead(2) { |status_2, bytes| @message_factory.system_realtime(status_2) }
+        end
+        else
+          use_running_status if running_status_possible?            
+      end
+      output
+    end
+    
+    private
+    
+    def running_status_possible?
+      !@running_status.nil?
+    end
+    
+    def use_running_status
+      lookahead(@running_status[:num], :status_nibble => @running_status[:status_nibble], &@running_status[:block])
+    end  
+    
+    def populate_current
+      @current = (@buffer[@iterator, (@buffer.length - @iterator)])
+    end
+    
+    def lookahead(num, options = {}, &block)
+      recursive = !options[:recursive].nil? && options[:recursive]
+      status_nibble = options[:status_nibble]
+      processed = []
+      msg = nil             
+      # do we have enough nibbles for num bytes?
+      if @current.slice(0, num).length >= num
+
+        # if so shift those nibbles off of the array and call block with them        
+        processed += @current.slice!(0, num)
+        status_nibble ||= processed[1]       
+        # send the nibbles to the block as bytes         
+        # return the evaluated block and the remaining nibbles       
+        bytes = TypeConversion.hex_chars_to_numeric_bytes(processed)
+        # record the current situation in case running status comes up next round
+        @running_status = { 
+          :block => block, 
+          :num => num - 2, 
+          :status_nibble => status_nibble 
+        }
+        msg = block.call(status_nibble.hex, bytes)
+      elsif num > 0 && recursive
+        msg, processed = *lookahead(num-2, options, &block)
+      end
+      [msg, processed]
+    end
+        
+    def lookahead_sysex(&block)
+      processed = []
+      msg = nil      
+      @running_status = nil
+      
+      bytes = TypeConversion.hex_chars_to_numeric_bytes(@current)
+      ind = bytes.index(0xF7)
+      unless ind.nil?
+        msg = block.call(bytes.slice!(0, ind + 1))
+        processed += @current.slice!(0, (ind + 1) * 2)
+      end
+      [msg, processed]
+    end
+    
+    # for testing
+    def buffer=(val)
+      @buffer=val
+    end
+    
+    def current
+      @current
+    end
+    
+  end
+
+end

data/lib/nibbler/type_conversion.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+#
+module Nibbler
+ 
+  # this is a helper for converting nibbles and bytes
+  module TypeConversion
+    
+    def self.hex_chars_to_numeric_bytes(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
+    
+    # converts a string of hex digits to bytes
+    def self.hex_str_to_hex_chars(str)
+      str.split(//)    
+    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/nibbler.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+#
+# Parse MIDI Messages
+# (c)2011 Ari Russo and licensed under the Apache 2.0 License
+# 
+
+require 'forwardable'
+
+require 'nibbler/nibbler'
+require 'nibbler/parser'
+require 'nibbler/type_conversion'
+require 'nibbler/hex_char_array_filter'
+
+#
+# Parse MIDI Messages
+#
+module Nibbler
+  
+  VERSION = "0.0.3"
+
+  # shortcut to Parser.new
+  def self.new(*a, &block)
+    Nibbler.new(*a, &block)
+  end
+
+end
+	

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: midi-nibbler
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.3
+platform: ruby
+authors: 
+- Ari Russo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-04 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: midi-message
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: midilib
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: Parse MIDI Messages.
+email: 
+- ari.russo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/nibbler.rb
+- lib/nibbler/nibbler.rb
+- lib/nibbler/midi-message_factory.rb
+- lib/nibbler/parser.rb
+- lib/nibbler/midilib_factory.rb
+- lib/nibbler/hex_char_array_filter.rb
+- lib/nibbler/type_conversion.rb
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/arirusso/nibbler
+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: nibbler
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Parse MIDI Messages.
+test_files: []
+