mtk 0.0.2 → 0.0.3

data/lib/mtk/lang/parser.rb

@@ -0,0 +1,29 @@
+require 'citrus'
+
+# @private
+class Citrus::Match
+  def values_of(token_name)
+    captures[token_name].map{|token| token.value }
+  end
+end
+
+Citrus.load File.join(File.dirname(__FILE__),'mtk_grammar')
+
+module MTK
+  module Lang
+
+    # Parser for the {file:lib/mtk/lang/mtk_grammar.citrus MTK grammar}
+    class Parser
+
+      def self.parse(syntax, root=:root, dump=false)
+        syntax = syntax.to_s.strip
+        return nil if syntax.empty?
+        matcher = ::MTK_Grammar.parse(syntax, :root => root)
+        puts matcher.dump if dump
+        matcher.value
+      end
+
+    end
+
+  end
+end

data/lib/mtk/melody.rb

@@ -0,0 +1,94 @@
+module MTK
+
+  # An ordered collection of {Pitch}es.
+  #
+  # The "horizontal" (sequential) pitch collection.
+  #
+  # Unlike the strict definition of melody, this class is fairly abstract and only models a succession of pitches.
+  # To create a true, playable melody one must combine an MTK::Melody and rhythms into a {Timeline}.
+  #
+  # @see Chord
+  #
+  class Melody
+    include Helpers::PitchCollection
+
+    attr_reader :pitches
+
+    # @param pitches [#to_a] the collection of pitches
+    # @see MTK#Melody
+    #
+    def initialize(pitches)
+      @pitches = pitches.to_a.clone.freeze
+    end
+
+    def self.from_pitch_classes(pitch_classes, start=Constants::Pitches::C4, max_distance=12)
+      pitch = start
+      pitches = []
+      pitch_classes.each do |pitch_class|
+        pitch = pitch.nearest(pitch_class)
+        pitch -= 12 if pitch > start+max_distance # keep within max_distance of start (default is one octave)
+        pitch += 12 if pitch < start-max_distance
+        pitches << pitch
+      end
+      new pitches
+    end
+
+    # @see Helper::Collection
+    def elements
+      @pitches
+    end
+
+    # Convert to an Array of pitches.
+    # @note this returns a mutable copy the underlying @pitches attribute, which is otherwise unmutable
+    alias :to_pitches :to_a
+
+    def self.from_a enumerable
+      new enumerable
+    end
+
+    def to_pitch_class_set(remove_duplicates=true)
+      PitchClassSet.new(remove_duplicates ? pitch_classes.uniq : pitch_classes)
+    end
+
+    def pitch_classes
+      @pitch_classes ||= @pitches.map{|p| p.pitch_class }
+    end
+
+    # @param other [#pitches, Enumerable]
+    def == other
+      if other.respond_to? :pitches
+        @pitches == other.pitches
+      elsif other.is_a? Enumerable
+        @pitches == other.to_a
+      else
+        @pitches == other
+      end
+    end
+
+    # Compare for equality, ignoring order and duplicates
+    # @param other [#pitches, Array, #to_a]
+    def =~ other
+      @normalized_pitches ||= @pitches.uniq.sort
+      @normalized_pitches == case
+        when other.respond_to?(:pitches) then other.pitches.uniq.sort
+        when (other.is_a? Array and other.frozen?) then other
+        when other.respond_to?(:to_a) then other.to_a.uniq.sort
+        else other
+      end
+    end
+
+    def to_s
+      '[' + @pitches.map{|pitch| pitch.to_s}.join(', ') + ']'
+    end
+
+  end
+
+  # Construct an ordered {Melody} that allows duplicates
+  # @see #Melody
+  # @see #Chord
+  def Melody(*anything)
+    Melody.new Helpers::Convert.to_pitches(*anything)
+  end
+  module_function :Melody
+
+end

data/lib/mtk/midi/dls_synth_device.rb

@@ -0,0 +1,144 @@
+require 'ffi'
+
+module MTK
+  module MIDI
+
+    # An output device for Apple's built-in "DLS" synthesizer on OS X
+    class DLSSynthDevice
+
+      module AudioToolbox
+        extend FFI::Library
+        ffi_lib '/System/Library/Frameworks/AudioToolbox.framework/Versions/Current/AudioToolbox'
+        ffi_lib '/System/Library/Frameworks/AudioUnit.framework/Versions/Current/AudioUnit'
+
+        class ComponentDescription < FFI::Struct
+          layout :componentType, :int,
+                 :componentSubType, :int,
+                 :componentManufacturer, :int,
+                 :componentFlags, :int,
+                 :componentFlagsMask, :int
+        end
+
+        def self.to_bytes(s)
+          bytes = 0
+          s.each_byte do |byte|
+            bytes <<= 8
+            bytes += byte
+          end
+          return bytes
+        end
+
+        AUDIO_UNIT_MANUFACTURER_APPLE = to_bytes('appl')
+        AUDIO_UNIT_TYPE_MUSIC_DEVICE = to_bytes('aumu')
+        AUDIO_UNIT_SUBTYPE_DLS_SYNTH = to_bytes('dls ')
+        AUDIO_UNIT_TYPE_OUTPUT = to_bytes('auou')
+        AUDIO_UNIT_SUBTYPE_DEFAULT_OUTPUT = to_bytes('def ')
+
+        # int NewAUGraph(void *)
+        attach_function :NewAUGraph, [:pointer], :int
+
+        # int AUGraphAddNode(void *, ComponentDescription *, void *)
+        attach_function :AUGraphAddNode, [:pointer, :pointer, :pointer], :int
+
+        # int AUGraphOpen(void *)
+        attach_function :AUGraphOpen, [:pointer], :int
+
+        # int AUGraphConnectNodeInput(void *, void *, int, void *, int)
+        attach_function :AUGraphConnectNodeInput, [:pointer, :pointer, :int, :pointer, :int], :int
+
+        # int AUGraphNodeInfo(void *, void *, ComponentDescription *, void *)
+        attach_function :AUGraphNodeInfo, [:pointer, :pointer, :pointer, :pointer], :int
+
+        # int AUGraphInitialize(void *)
+        attach_function :AUGraphInitialize, [:pointer], :int
+
+        # int AUGraphStart(void *)
+        attach_function :AUGraphStart, [:pointer], :int
+
+        # int AUGraphStop(void *)
+        attach_function :AUGraphStop, [:pointer], :int
+
+        # int DisposeAUGraph(void *)
+        attach_function :DisposeAUGraph, [:pointer], :int
+
+        # void * CAShow(void *)
+        attach_function :CAShow, [:pointer], :void
+
+        # void * MusicDeviceMIDIEvent(void *, int, int, int, int)
+        attach_function :MusicDeviceMIDIEvent, [:pointer, :int, :int, :int, :int], :void
+
+      end
+
+
+      ##################################
+
+      def name
+        'Apple DLS Synthesizer'
+      end
+
+
+      def require_noerr(action_description, &block)
+        if block.call != 0
+          fail "Failed to #{action_description}"
+        end
+      end
+
+
+      def open
+        synth_pointer = FFI::MemoryPointer.new(:pointer)
+        graph_pointer = FFI::MemoryPointer.new(:pointer)
+        synth_node_pointer = FFI::MemoryPointer.new(:pointer)
+        out_node_pointer = FFI::MemoryPointer.new(:pointer)
+
+        cd = AudioToolbox::ComponentDescription.new
+        cd[:componentManufacturer] = AudioToolbox::AUDIO_UNIT_MANUFACTURER_APPLE
+        cd[:componentFlags] = 0
+        cd[:componentFlagsMask] = 0
+
+        require_noerr('create AUGraph') { AudioToolbox.NewAUGraph(graph_pointer) }
+        @graph = graph_pointer.get_pointer(0)
+
+        cd[:componentType] = AudioToolbox::AUDIO_UNIT_TYPE_MUSIC_DEVICE
+        cd[:componentSubType] = AudioToolbox::AUDIO_UNIT_SUBTYPE_DLS_SYNTH
+        require_noerr('add synthNode') { AudioToolbox.AUGraphAddNode(@graph, cd, synth_node_pointer) }
+        synth_node = synth_node_pointer.get_pointer(0)
+
+        cd[:componentType] = AudioToolbox::AUDIO_UNIT_TYPE_OUTPUT
+        cd[:componentSubType] = AudioToolbox::AUDIO_UNIT_SUBTYPE_DEFAULT_OUTPUT
+        require_noerr('add outNode') { AudioToolbox.AUGraphAddNode(@graph, cd, out_node_pointer) }
+        out_node = out_node_pointer.get_pointer(0)
+
+        require_noerr('open graph') { AudioToolbox.AUGraphOpen(@graph) }
+
+        require_noerr('connect synth to out') { AudioToolbox.AUGraphConnectNodeInput(@graph, synth_node, 0, out_node, 0) }
+
+        require_noerr('graph info') { AudioToolbox.AUGraphNodeInfo(@graph, synth_node, nil, synth_pointer) }
+        @synth = synth_pointer.get_pointer(0)
+
+        require_noerr('init graph') { AudioToolbox.AUGraphInitialize(@graph) }
+        require_noerr('start graph') { AudioToolbox.AUGraphStart(@graph) }
+
+        # AudioToolbox.CAShow(@graph) # for debugging
+      end
+
+
+      def message(*args)
+        arg0 = args[0] || 0
+        arg1 = args[1] || 0
+        arg2 = args[2] || 0
+        AudioToolbox.MusicDeviceMIDIEvent(@synth, arg0, arg1, arg2, 0)
+      end
+
+
+      def close
+        if @graph
+          AudioToolbox.AUGraphStop(@graph)
+          AudioToolbox.DisposeAUGraph(@graph)
+        end
+      end
+    end
+
+  end
+end
+
+

data/lib/mtk/midi/dls_synth_output.rb

@@ -0,0 +1,62 @@
+require 'mtk/midi/dls_synth_device'
+
+module MTK
+  module MIDI
+
+    # Provides realtime MIDI output on OS X to the built-in "DLS" Synthesizer
+    # @note This class is optional and only available if you require 'mtk/midi/dls_synth_output'.
+    #       It depends on the 'gamelan' gem.
+    class DLSSynthOutput < Output
+
+      public_class_method :new
+
+      def self.devices
+        @devices ||= [DLSSynthDevice.new]
+      end
+
+      def self.devices_by_name
+        @devices_by_name ||= {devices.first.name => devices.first}
+      end
+
+
+      ######################
+      protected
+
+      # (see Output#note_on)
+      def note_on(pitch, velocity, channel)
+        @device.message(0x90|channel, pitch, velocity)
+      end
+
+      # (see Output#note_off)
+      def note_off(pitch, velocity, channel)
+        @device.message(0x80|channel, pitch, velocity)
+      end
+
+      # (see Output#control)
+      def control(number, midi_value, channel)
+        @device.message(0xB0|channel, number, midi_value)
+      end
+
+      # (see Output#channel_pressure)
+      def channel_pressure(midi_value, channel)
+        @device.message(0xD0|channel, midi_value, 0)
+      end
+
+      # (see Output#poly_pressure)
+      def poly_pressure(pitch, midi_value, channel)
+        @device.message(0xA0|channel, pitch, midi_value)
+      end
+
+      # (see Output#bend)
+      def bend(midi_value, channel)
+        @device.message(0xE0|channel, midi_value & 127, (midi_value >> 7) & 127)
+      end
+
+      # (see Output#program)
+      def program(number, channel)
+        @device.message(0xC0|channel, number, 0)
+      end
+    end
+  end
+end
+

data/lib/mtk/midi/file.rb

@@ -1,9 +1,11 @@
-require 'rubygems'
 require 'midilib'
 
 module MTK
   module MIDI
 
+    # MIDI file I/O: reads MIDI files into {Timeline}s and writes {Timeline}s to MIDI files.
+    # @note This class is optional and only available if you require 'mtk/midi/file'.
+    #       It depends on the 'midilib' gem.
     class File
       def initialize file
         if file.respond_to? :path
@@ -15,7 +17,6 @@ module MTK
 
       # Read a MIDI file into an Array of {Timeline}s
       #
-      # @param filepath [String, #path] path of the file to be written
       # @return [Timeline]
       #
       def to_timelines
@@ -27,25 +28,34 @@ module MTK
           pulses_per_beat = sequence.ppqn.to_f
           track_idx = -1
 
-          for track in sequence
+          sequence.each do |track|
             track_idx += 1
             timeline = Timeline.new
             note_ons = {}
             #puts "TRACK #{track_idx}"
 
-            for event in track
+            track.each do |event|
               #puts "#{event.class}: #{event}   @#{event.time_from_start}"
+              time = (event.time_from_start)/pulses_per_beat
+
               case event
                 when ::MIDI::NoteOn
-                  note_ons[event.note] = event
+                  note_ons[event.note] = [time,event]
 
                 when ::MIDI::NoteOff
-                  if on_event = note_ons.delete(event.note)
-                    time = (on_event.time_from_start)/pulses_per_beat
-                    duration = (event.time_from_start - on_event.time_from_start)/pulses_per_beat
-                    note = Note.from_midi event.note, on_event.velocity, duration
-                    timeline.add time, note
+                  on_time,on_event = note_ons.delete(event.note)
+                  if on_event
+                    duration = time - on_time
+                    note = MTK::Events::Note.from_midi(event.note, on_event.velocity, duration)
+                    timeline.add on_time, note
                   end
+
+                when ::MIDI::Controller, ::MIDI::PolyPressure, ::MIDI::ChannelPressure, ::MIDI::PitchBend, ::MIDI::ProgramChange
+                  timeline.add time, MTK::Events::Parameter.from_midi(*event.data_as_bytes)
+
+                when ::MIDI::Tempo
+                  # Not sure if event.tempo needs to be converted? TODO: test!
+                  timeline.add time, MTK::Events::Parameter.new(:tempo, :value => event.tempo)
               end
             end
             timelines << timeline
@@ -56,43 +66,59 @@ module MTK
 
       def write(anything)
         case anything
-          when Timeline then
-            write_timeline(anything)
-          when Array then
-            write_timelines(anything)
-          else
-            raise "#{self.class}#write doesn't understand #{anything.class}"
+          when Timeline then write_timeline(anything)
+          when Enumerable then write_timelines(anything)
+          else raise "#{self.class}#write doesn't understand #{anything.class}"
         end
       end
 
       def write_timelines(timelines, parent_sequence=nil)
         sequence = parent_sequence || ::MIDI::Sequence.new
-        for timeline in timelines
-          write_timeline(timeline, sequence)
-        end
+        timelines.each{|timeline| write_timeline(timeline, sequence) }
         write_to_disk sequence unless parent_sequence
       end
 
       # Write the Timeline as a MIDI file
       #
-      # @param [Timeline]
+      # @param timeline [Timeline]
       def write_timeline(timeline, parent_sequence=nil)
         sequence = parent_sequence || ::MIDI::Sequence.new
         clock_rate = sequence.ppqn
         track = add_track sequence
-        channel = 1
 
-        for time,events in timeline
+        timeline.each do |time,events|
           time *= clock_rate
 
-          for event in events
+          events.each do |event|
             next if event.rest?
 
-            if event.is_a? Note
-              pitch, velocity = event.pitch, event.velocity
-              add_event track, time => note_on(channel, pitch, velocity)
-              duration = event.duration_in_pulses(clock_rate)
-              add_event track, time+duration => note_off(channel, pitch, velocity)
+            channel = event.channel || 0
+
+            case event.type
+              when :note
+                pitch, velocity = event.midi_pitch, event.velocity
+                add_event track, time => note_on(channel, pitch, velocity)
+                duration = event.duration_in_pulses(clock_rate)
+                add_event track, time+duration => note_off(channel, pitch, velocity)
+
+              when :control
+                add_event track, time => cc(channel, event.number, event.midi_value)
+
+              when :pressure
+                if event.number
+                  add_event track, time => poly_pressure(channel, event.number, event.midi_value)
+                else
+                  add_event track, time => channel_pressure(channel, event.midi_value)
+                end
+
+              when :bend
+                add_event track, time => pitch_bend(channel, event.midi_value)
+
+              when :program
+                add_event track, time => program(channel, event.midi_value)
+
+              when :tempo
+                add_event track, time => tempo(event.value)
             end
           end
         end
@@ -106,14 +132,15 @@ module MTK
       private
 
       def write_to_disk(sequence)
+        puts "Writing file #{@file}"
         ::File.open(@file, 'wb') { |f| sequence.write f }
       end
 
       def print_midi sequence
-        for track in sequence
+        sequence.each do |track|
           puts "\n*** track \"#{track.name}\""
           puts "#{track.events.length} events"
-          for event in track
+          track.each do |event|
             puts "#{event.to_s} (#{event.time_from_start})"
           end
         end
@@ -125,7 +152,7 @@ module MTK
         ::MIDI::Tempo.new(ms_per_quarter_note)
       end
 
-      def program(program_number)
+      def program(channel, program_number)
         ::MIDI::ProgramChange.new(channel, program_number)
       end
 
@@ -138,7 +165,15 @@ module MTK
       end
 
       def cc(channel, controller, value)
-        ::MIDI::Controller.new(channel, controller.to_i, value.to_i)
+        ::MIDI::Controller.new(channel, controller, value)
+      end
+
+      def poly_pressure(channel, pitch, value)
+        ::MIDI::PolyPressure(channel, pitch.to_i, value)
+      end
+
+      def channel_pressure(channel, value)
+        ::MIDI::ChannelPressure(channel, value)
       end
 
       def pitch_bend(channel, value)