jsound 0.1.0-java

data/lib/jsound/midi/devices/monitor.rb

@@ -0,0 +1,18 @@
+module JSound
+  module Midi
+    module Devices
+
+      # A device that prints out all incoming MIDI message.
+      class Monitor < Device
+        def message(message)
+          source = message.source
+          if source and source.respond_to? :description
+            source = "#{source.description} => "
+          end
+          puts "#{source}#{message}"
+        end
+      end
+
+    end
+  end
+end

data/lib/jsound/midi/devices/output_device.rb

@@ -0,0 +1,36 @@
+module JSound
+  module Midi
+    module Devices
+
+      # A device that sends all it's received messages to a system MIDI output port.
+      #
+      # Available outputs are contained in the {OUTPUTS} list in the {Midi} module.
+      #
+      class OutputDevice < JDevice
+
+        # Wrap a javax.sound.midi.MidiDevice transmitter to provide MIDI output.
+        #
+        # @note Typically you won't instantiate these directly. Instead, find an output via the {OUTPUTS} list in the {Midi} module.
+        #
+        def initialize(java_device)
+          super(java_device, :output)
+        end
+
+        def output= device
+          raise "#{self.class} cannot be assigned an output"
+        end
+
+        def message(message)
+          # unwrap the ruby message wrapper, if needed:
+          message = message.to_java if message.respond_to? :to_java
+
+          # Use java_send to call Receiver.send() since it conflicts with Ruby's built-in send method
+          # -1 means no timestamp, so we're not supporting timestamps
+          @java_device.receiver.java_send(:send, [javax.sound.midi.MidiMessage, Java::long], message, -1)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/jsound/midi/devices/recorder.rb

@@ -0,0 +1,56 @@
+module JSound
+  module Midi
+    module Devices
+
+      # A Device that records incoming messages, and the timestamp at which they were received.
+      class Recorder < Device
+
+        # The recorded [message,timestamp] pairs
+        attr_reader :messages_with_timestamps
+
+        # The recorded messages without timestamps
+        def messages
+          @messages_with_timestamps.map{|m,t| m }
+        end
+
+        def initialize(autostart=true)
+          clear
+          if autostart
+            start
+          else
+            stop
+          end
+        end
+
+        # clear any recorded messages
+        def clear
+          @messages_with_timestamps = []
+        end
+
+        # start recording
+        def open
+          @recording = true
+        end
+        alias start open
+
+        # stop recording
+        def close
+          @recording = false
+        end
+        alias stop close
+
+        # true if this object is currently recording
+        def open?
+          @recording
+        end
+        alias recording? open?
+
+        def message(message)
+          @messages_with_timestamps << [message, Time.now.to_i] if recording?
+        end
+
+      end
+
+    end
+  end
+end

data/lib/jsound/midi/devices/repeater.rb

@@ -0,0 +1,28 @@
+module JSound
+  module Midi
+    module Devices
+
+      # A device which repeats the input message to multiple outputs.
+      class Repeater < Device
+
+        # connect device(s) as the outputs for this device
+        # @param [Enumberable, Device] the device or devices to connect, or nil to disconnect the currently connected device
+        # @see {#>>}
+        def output= device
+          device = [device] if not device.is_a? Enumerable
+          super
+        end
+
+        def message(message)
+          if @output
+            for device in @output
+              device.message(message)
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/jsound/midi/devices/transformer.rb

@@ -0,0 +1,30 @@
+module JSound
+  module Midi
+    module Devices
+
+      class Transformer < Device
+
+        # The transformation block: a lambda that takes a message and returns
+        # either a transformed message or an Enumerable list of messages
+        attr_accessor :message_processor
+
+        def initialize(&message_processor)
+          @message_processor = message_processor
+        end
+
+        def message(message)
+          if @output and @message_processor
+            transformed_message = @message_processor.call(message)
+            if transformed_message.is_a? Enumerable
+              transformed_message.each{|m| @output.message(m) }
+            else
+              @output.message(transformed_message) if transformed_message
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/jsound/midi/message.rb

@@ -0,0 +1,165 @@
+module JSound
+  module Midi
+
+    # A generic MIDI message.
+    # The various subclasses in this module deal with specific message details.
+    # See http://www.midi.org/techspecs/midimessages.php
+    # for info on how the MIDI spec defines these messages.
+    class Message
+      include JSound::Mixins::TypeFromClassName
+
+      # The MIDI input {Device} which received this message.
+      attr_reader :source
+
+      # The variable data for this message type. Contents depend on the message type.
+      # @example a NoteOn's #data is [pitch,velocity]
+      attr_reader :data
+
+      # The channel number of the message
+      attr_reader :channel
+
+      # The type of message, such as :note_on or :control_change
+      # @return [Symbol]
+      attr_reader :type
+
+      def initialize(data, channel=0, options={})
+        @data = data
+        @channel = channel
+
+        # Generic Message objects specify a type explicitly (see initialize).
+        # Subclasses will typically use the class type (see JSound::Mixins::TypeFromClassName).
+        @type = options[:type] ||= self.class.type
+
+        @java_message = options[:java_message]
+
+        @source = options[:source]
+      end
+
+      # Map java message status values to ruby classes
+      CLASS_FOR_STATUS = {}
+
+      # Map ruby classes to java message status values
+      STATUS_FOR_CLASS = {}
+
+      def self.inherited(child_class)
+        # I'm using the convention that the message class names
+        # correspond to the java ShortMessage constants, like:
+        # NoteOn => ShortMessage::NOTE_ON
+        const_name = child_class.type.to_s.upcase
+        if javax.sound.midi.ShortMessage.const_defined? const_name
+          status = javax.sound.midi.ShortMessage.const_get(const_name)
+          CLASS_FOR_STATUS[status] = child_class
+          STATUS_FOR_CLASS[child_class] = status
+        end
+      end
+
+      TYPE_FOR_STATUS = {
+        javax.sound.midi.ShortMessage::ACTIVE_SENSING        => :active_sensing,
+        javax.sound.midi.ShortMessage::CONTINUE              => :continue,
+        javax.sound.midi.ShortMessage::END_OF_EXCLUSIVE      => :end_of_exclusive,
+        javax.sound.midi.ShortMessage::MIDI_TIME_CODE        => :multi_time_code,
+        javax.sound.midi.ShortMessage::SONG_POSITION_POINTER => :song_position_pointer,
+        javax.sound.midi.ShortMessage::SONG_SELECT           => :song_select,
+        javax.sound.midi.ShortMessage::START                 => :start,
+        javax.sound.midi.ShortMessage::STOP                  => :stop,
+        javax.sound.midi.ShortMessage::SYSTEM_RESET          => :system_reset,
+        javax.sound.midi.ShortMessage::TIMING_CLOCK          => :timing_clock,
+        javax.sound.midi.ShortMessage::TUNE_REQUEST          => :tune_request
+      }
+
+      STATUS_FOR_TYPE = TYPE_FOR_STATUS.invert
+
+      # true when the argument has the same {#type}, {#channel}, and {#data}
+      def == other
+        other.respond_to? :type and type == other.type and
+        other.respond_to? :channel and channel == other.channel and
+        other.respond_to? :data and data == other.data
+      end
+
+      def self.from_java(java_message, options={})
+        case java_message
+        when javax.sound.midi.SysexMessage
+          type = :sysex
+          data = java_message.data # this is a byte array in Java, might need conversion?
+
+        when javax.sound.midi.MetaMessage
+          type = :meta
+          data = java_message.data # this is a byte array in Java, might need conversion?
+
+        when javax.sound.midi.ShortMessage
+          # For command-type messages, the least significant 4 bits of the status byte will be the channel number.
+          # java_message.command will return the desired command's status code in this case, or
+          # we can just use a bitmask to grab the most significant 4 bits of the status byte like so:
+          status = (java_message.status & 0xF0)
+
+          message_class = CLASS_FOR_STATUS[status]
+          return message_class.from_java(java_message, options) if message_class
+
+          type = TYPE_FOR_STATUS[status] || :unknown
+          data = [java_message.data1, java_message.data2]
+
+        else
+          type  = :unknown
+          data = []
+        end
+
+        new data, java_message.channel, options.merge({:type => type, :java_message => java_message})
+      end
+
+      def to_java
+        if not @java_message
+          @java_message = javax.sound.midi.ShortMessage.new
+          update_java_message
+        end
+        # else, since all ruby message classes are backed by "ShortMessage",
+        # we should be able to rely on @java_message being set for everything else
+        @java_message
+      end
+
+      def update_java_message
+        @java_message.setMessage(status, @channel, @data[0], @data[1]) if @java_message
+      end
+
+      def data= data
+        @data = data
+        update_java_message
+      end
+
+      def data1
+        @data[0] if @data
+      end
+
+      def data1= data
+        @data[0] = data
+        update_java_message
+      end
+
+      def data2
+        @data[1] if @data
+      end
+
+      def data2= data
+        @data[1] = data
+        update_java_message
+      end
+
+      def status
+        @status ||= (STATUS_FOR_CLASS[self.class] || STATUS_FOR_TYPE[@type])
+      end
+
+      def value
+        @data
+      end
+
+      def to_s
+        "#{type}(#{channel}): #{value.inspect}"
+      end
+
+      def clone
+        self.class.new(@data, @channel, {:type => @type})
+      end
+
+    end
+
+  end
+end

data/lib/jsound/midi/message_builder.rb

@@ -0,0 +1,52 @@
+module JSound
+  module Midi
+
+    # A collection of methods for building MIDI messages.
+    module MessageBuilder
+
+      def note_on(pitch, velocity=127, channel=0)
+        Messages::NoteOn.new(pitch,velocity,channel)
+      end
+
+      def note_off(pitch, velocity=127, channel=0)
+        Messages::NoteOff.new(pitch,velocity,channel)
+      end
+
+      # Most methods in here take 7-bit ints for their args, but this one takes a 14-bit
+      # The value can be an int in the range 0-16383 (8192 is no bend)
+      # or it can be a float, which is assumed to be in the range -1.0 to 1.0
+      def pitch_bend(value, channel=0)
+        Messages::PitchBend.new(value, channel)
+      end
+
+      def control_change(control, value, channel=0)
+        Messages::ControlChange.new(control, value, channel)
+      end
+
+      def all_notes_off(channel=0)
+        control_change(123, 0, channel)
+      end
+
+      def channel_pressure(pressure, channel=0)
+        Messages::ChannelPressure.new(pressure, channel)
+      end
+      alias channel_aftertouch channel_pressure
+
+      def poly_pressure(pitch, pressure, channel=0)
+        Messages::PolyPressure.new(pitch, pressure, channel)
+      end
+      alias poly_aftertouch poly_pressure
+
+      def program_change(program, channel=0)
+        Messages::ProgramChange.new(program, channel)
+      end
+
+      # Make all methods be module functions (accessible by sending the method name to module directly)
+      instance_methods.each do |method|
+        module_function method
+      end
+
+    end
+
+  end
+end

data/lib/jsound/midi/messages/channel_pressure.rb

@@ -0,0 +1,26 @@
+module JSound
+  module Midi
+    module Messages
+
+      class ChannelPressure < Message
+
+        def initialize(pressure, channel=0, options={})
+          super([pressure, 0], channel, options)
+        end
+
+        alias pressure data1
+        alias pressure= data1=
+
+        def self.from_java(java_message, options={})
+          new java_message.data1, java_message.channel, options.merge({:java_message => java_message})
+        end
+
+        def clone
+          self.class.new(pressure,@channel)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/jsound/midi/messages/control_change.rb

@@ -0,0 +1,29 @@
+module JSound
+  module Midi
+    module Messages
+
+      class ControlChange < Message
+
+        def initialize(control, value, channel=0, options={})
+          super([control,value], channel, options)
+        end
+
+        alias control data1
+        alias control= data1=
+
+        alias value data2
+        alias value= data2=
+
+        def self.from_java(java_message, options={})
+          new java_message.data1, java_message.data2, java_message.channel, options.merge({:java_message => java_message})
+        end
+
+        def clone
+          self.class.new(control,value,@channel)
+        end
+
+      end
+
+    end
+  end
+end