jmtk 0.0.3.3-java

data/lib/mtk/groups/pitch_collection.rb

@@ -0,0 +1,23 @@
+module MTK
+  module Groups
+
+    # An extension to {Collection}, which provides additional transformations for pitch-like collections.
+    #
+    module PitchCollection
+      include Collection
+
+      # Transpose all elements upward by the given interval
+      # @param interval_in_semitones [Numeric] an interval in semitones
+      def transpose interval_in_semitones
+        map{|elem| elem + interval_in_semitones }
+      end
+
+      # Invert all elements around the given inversion point
+      # @param inversion_point [Numeric] the value around which all elements will be inverted (defaults to the first element in the collection)
+      def invert(inversion_point=first)
+        map{|elem| elem.invert(inversion_point) }
+      end
+
+    end
+  end
+end

data/lib/mtk/io/dls_synth_device.rb

@@ -0,0 +1,146 @@
+require 'ffi'
+
+module MTK
+  module IO
+
+    # An output device for Apple's built-in "DLS" synthesizer on OS X
+    class DLSSynthDevice
+
+      # @private
+      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'
+
+        # @private
+        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/io/dls_synth_output.rb

@@ -0,0 +1,62 @@
+require 'mtk/io/dls_synth_device'
+
+module MTK
+  module IO
+
+    # 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 < MIDIOutput
+
+      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 MIDIOutput#note_on)
+      def note_on(pitch, velocity, channel)
+        @device.message(0x90|channel, pitch, velocity)
+      end
+
+      # (see MIDIOutput#note_off)
+      def note_off(pitch, velocity, channel)
+        @device.message(0x80|channel, pitch, velocity)
+      end
+
+      # (see MIDIOutput#control)
+      def control(number, midi_value, channel)
+        @device.message(0xB0|channel, number, midi_value)
+      end
+
+      # (see MIDIOutput#channel_pressure)
+      def channel_pressure(midi_value, channel)
+        @device.message(0xD0|channel, midi_value, 0)
+      end
+
+      # (see MIDIOutput#poly_pressure)
+      def poly_pressure(pitch, midi_value, channel)
+        @device.message(0xA0|channel, pitch, midi_value)
+      end
+
+      # (see MIDIOutput#bend)
+      def bend(midi_value, channel)
+        @device.message(0xE0|channel, midi_value & 127, (midi_value >> 7) & 127)
+      end
+
+      # (see MIDIOutput#program)
+      def program(number, channel)
+        @device.message(0xC0|channel, number, 0)
+      end
+    end
+  end
+end
+

data/lib/mtk/io/jsound_input.rb

@@ -0,0 +1,87 @@
+require 'jsound'
+
+module MTK
+  module IO
+
+    # Provides realtime MIDI input for JRuby via the jsound gem.
+    # @note This class is optional and only available if you require 'mtk/midi/jsound_input'.
+    #       It depends on the 'jsound' gem.
+    class JSoundInput < MIDIInput
+
+      public_class_method :new
+
+      def self.devices
+        @devices ||= ::JSound::Midi::INPUTS.devices
+      end
+
+      def self.devices_by_name
+        @devices_by_name ||= devices.each_with_object( Hash.new ){|device,hash| hash[device.description] = device }
+      end
+
+
+      attr_reader :device
+
+      def initialize(input_device, options={})
+        @device = input_device
+        @recorder = ::JSound::Midi::Devices::Recorder.new(false)
+        @device.open
+      end
+
+      def name
+        @device.description
+      end
+
+      def record(options={})
+        if options[:monitor]
+          @monitor = ::JSound::Midi::Devices::Monitor.new
+          @device >> [@monitor, @recorder]
+        else
+          @device >> @recorder
+        end
+
+        @recorder.clear
+        @recorder.start
+      end
+
+      def stop
+        @recorder.stop
+      end
+
+      def to_timeline(options={})
+        bpm = options.fetch :bmp, 120
+        beats_per_second = bpm.to_f/60
+        timeline = Timeline.new
+        note_ons = {}
+        start = nil
+
+        @recorder.messages_with_timestamps.each do |message,time|
+          start = time unless start
+          time -= start
+          time /= beats_per_second
+
+          case message.type
+            when :note_on
+              note_ons[message.pitch] = [message,time]
+
+            when :note_off
+              if note_ons.has_key? message.pitch
+                note_on, start_time = note_ons.delete(message.pitch)
+                duration = time - start_time
+                note = MTK::Events::Note.from_midi(note_on.pitch, note_on.velocity, duration, message.channel)
+                timeline.add time,note
+              end
+
+            else timeline.add time, MTK::Events::Parameter.from_midi([message.type, message.channel], message.data1, message.data2)
+          end
+        end
+
+        timeline.quantize! options[:quantize] if options.key? :quantize
+        timeline.shift_to! options[:shift_to] if options.key? :shift_to
+
+        timeline
+      end
+
+    end
+  end
+end
+

data/lib/mtk/io/jsound_output.rb

@@ -0,0 +1,82 @@
+require 'jsound'
+
+module MTK
+  module IO
+
+    # Provides realtime MIDI output for JRuby via the jsound and gamelan gems.
+    # @note This class is optional and only available if you require 'mtk/midi/jsound_output'.
+    #       It depends on the 'jsound' and 'gamelan' gems.
+    class JSoundOutput < MIDIOutput
+
+      public_class_method :new
+
+      def self.devices
+        @devices ||= ::JSound::Midi::OUTPUTS.devices
+      end
+
+      def self.devices_by_name
+        @devices_by_name ||= devices.each_with_object( Hash.new ){|device,hash| hash[device.description] = device }
+      end
+
+
+      def initialize(device, options={})
+        @device = device
+
+        # and create an object for generating MIDI message to send to the output:
+        @generator = ::JSound::Midi::Devices::Generator.new
+
+        if options[:monitor]
+          @monitor = ::JSound::Midi::Devices::Monitor.new
+          @generator >> [@monitor, @device]
+        else
+          @generator >> @device
+        end
+        @device.open
+      end
+
+      def name
+        @device.description
+      end
+
+      ######################
+      protected
+
+      # (see MIDIOutput#note_on)
+      def note_on(pitch, velocity, channel)
+        @generator.note_on(pitch, velocity, channel)
+      end
+
+      # (see MIDIOutput#note_off)
+      def note_off(pitch, velocity, channel)
+        @generator.note_off(pitch, velocity, channel)
+      end
+
+      # (see MIDIOutput#control)
+      def control(number, midi_value, channel)
+        @generator.control_change(number, midi_value, channel)
+      end
+
+      # (see MIDIOutput#channel_pressure)
+      def channel_pressure(midi_value, channel)
+        @generator.channel_pressure(midi_value, channel)
+      end
+
+      # (see MIDIOutput#poly_pressure)
+      def poly_pressure(pitch, midi_value, channel)
+        @generator.poly_pressure(pitch, midi_value, channel)
+      end
+
+      # (see MIDIOutput#bend)
+      def bend(midi_value, channel)
+        @generator.pitch_bend(midi_value, channel)
+      end
+
+      # (see MIDIOutput#program)
+      def program(number, channel)
+        @generator.program_change(number, channel)
+      end
+
+    end
+  end
+end
+

data/lib/mtk/io/midi_file.rb

@@ -0,0 +1,209 @@
+require 'midilib'
+
+module MTK
+  module IO
+
+    # MIDI file I/O: reads MIDI files into {Events::Timeline}s and writes {Events::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 MIDIFile
+      def initialize file
+        if file.respond_to? :path
+          @file = file.path
+        else
+          @file = file.to_s
+        end
+      end
+
+      # Read a MIDI file into an Array of {Events::Timeline}s
+      #
+      # @return [Timeline]
+      #
+      def to_timelines
+        timelines = []
+
+        ::File.open(@file, 'rb') do |f|
+          sequence = ::MIDI::Sequence.new
+          sequence.read(f)
+          pulses_per_beat = sequence.ppqn.to_f
+          track_idx = -1
+
+          sequence.each do |track|
+            track_idx += 1
+            timeline =  MTK::Events::Timeline.new
+            note_ons = {}
+            #puts "TRACK #{track_idx}"
+
+            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] = [time,event]
+
+                when ::MIDI::NoteOff
+                  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, event.channel)
+                    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
+          end
+        end
+        timelines
+      end
+
+      def write(anything)
+        case anything
+          when  MTK::Events::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
+        timelines.each{|timeline| write_timeline(timeline, sequence) }
+        write_to_disk sequence unless parent_sequence
+      end
+
+      # Write the Timeline as a MIDI file
+      #
+      # @param timeline [Timeline]
+      def write_timeline(timeline, parent_sequence=nil)
+        sequence = parent_sequence || ::MIDI::Sequence.new
+        clock_rate = sequence.ppqn
+        track = add_track sequence
+
+        timeline.each do |time,events|
+          time *= clock_rate
+
+          events.each do |event|
+            next if event.rest?
+
+            channel = (event.channel || 1) - 1 # midilib seems to count channels from 0, hence the -1
+
+            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
+        track.recalc_delta_from_times
+
+        write_to_disk sequence unless parent_sequence
+      end
+
+
+      ########################
+      private
+
+      def write_to_disk(sequence)
+        puts "Writing file #{@file}" unless $__RUNNING_RSPEC_TESTS__
+        ::File.open(@file, 'wb') { |f| sequence.write f }
+      end
+
+      def print_midi sequence
+        sequence.each do |track|
+          puts "\n*** track \"#{track.name}\""
+          puts "#{track.events.length} events"
+          track.each do |event|
+            puts "#{event.to_s} (#{event.time_from_start})"
+          end
+        end
+      end
+
+      # Set tempo in terms of Quarter Notes per Minute (aka BPM)
+      def tempo(bpm)
+        ms_per_quarter_note = ::MIDI::Tempo.bpm_to_mpq(bpm)
+        ::MIDI::Tempo.new(ms_per_quarter_note)
+      end
+
+      def program(channel, program_number)
+        ::MIDI::ProgramChange.new(channel, program_number)
+      end
+
+      def note_on(channel, pitch, velocity)
+        ::MIDI::NoteOn.new(channel, pitch.to_i, velocity)
+      end
+
+      def note_off(channel, pitch, velocity)
+        ::MIDI::NoteOff.new(channel, pitch.to_i, velocity)
+      end
+
+      def cc(channel, controller, value)
+        ::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)
+        ::MIDI::PitchBend.new(channel, value)
+      end
+
+      def add_track sequence, opts={}
+        track = ::MIDI::Track.new(sequence)
+        track.name = opts.fetch :name, ''
+        sequence.tracks << track
+        track
+      end
+
+      def add_event track, event_hash
+        for time, event in event_hash
+          event.time_from_start = time.round # MIDI file event times must be in whole number pulses (typically 480 or 960 per quarter note)
+          track.events << event
+          event
+        end
+      end
+
+    end
+  end
+
+  # Shortcut for MTK::IO::MIDIFile.new
+  # @note Only available if you require 'mtk/midi/file'
+  def MIDIFile(f)
+    ::MTK::IO::MIDIFile.new(f)
+  end
+  module_function :MIDIFile
+
+end
+