diamond 0.5.1

data/lib/diamond/midi.rb

@@ -0,0 +1,165 @@
+module Diamond
+
+  # Enable the instrument to use MIDI
+  module MIDI
+
+    # Methods dealing with MIDI input
+    module Input
+
+      def self.included(base)
+        base.send(:extend, Forwardable)
+        base.send(:def_delegators, :@midi,
+                  :input,
+                  :inputs,
+                  :omni_on,
+                  :rx_channel, 
+                  :receive_channel,
+                  :rx_channel=,
+                  :receive_channel=)
+      end
+
+      # Add MIDI input notes 
+      # @param [Array<MIDIMessage>, MIDIMessage, *MIDIMessage] args
+      # @return [Array<MIDIMessage>]
+      def add(*args)
+        @midi.input << args
+      end
+      alias_method :<<, :add
+
+      # Add note offs to cancel input
+      # @param [Array<MIDIMessage>, MIDIMessage, *MIDIMessage] args
+      # @return [Array<MIDIMessage>]
+      def remove(*args)
+        messages = MIDIInstrument::Message.to_note_offs(*args)
+        @midi.input.add(messages.compact)
+      end
+
+      # Initialize adding and removing MIDI notes from the sequence
+      # @param [Sequence] sequence
+      # @return [Boolean]
+      def enable_note_control(sequence)  
+        @midi.input.receive(:class => MIDIMessage::NoteOn) do |event|
+          message = event[:message]
+          if @midi.input.channel.nil? || @midi.input.channel == message.channel
+            puts "[DEBUG] MIDI: add note from input #{message.name} channel: #{message.channel}" if @debug
+            sequence.add(message)
+          end
+        end 
+        @midi.input.receive(:class => MIDIMessage::NoteOff) do |event| 
+          message = event[:message]
+          if @midi.input.channel.nil? || @midi.input.channel == message.channel
+            puts "[DEBUG] MIDI: remove note from input #{message.name} channel: #{message.channel}" if @debug
+            sequence.remove(message)
+          end
+        end
+        true
+      end
+
+      # Initialize a user-defined map of control change messages
+      # @param [SequenceParameters] parameters
+      # @param [Array<Hash>] map
+      # @return [Boolean]
+      def enable_parameter_control(parameters, map)
+        from_range = 0..127
+        @midi.input.receive(:class => MIDIMessage::ControlChange) do |event|
+          message = event[:message]
+          if @midi.input.channel.nil? || @midi.input.channel == message.channel
+            index = message.index
+            mapping = map.find { |mapping| mapping[:index] == index }
+            property = mapping[:property]
+            to_range = SequenceParameters::RANGE[property]
+            value = message.value
+            value = Scale.transform(value).from(from_range).to(to_range)
+            puts "[DEBUG] MIDI: #{property}= #{value} channel: #{message.channel}" if @debug
+            parameters.send("#{property}=", value)
+          end
+        end
+      end
+
+      private
+
+      # @param [Array<UniMIDI::Input>] inputs
+      # @param [Hash] options
+      # @option options [Fixnum] :channel The receive channel (also: :rx_channel)
+      def initialize_input(inputs, options = {})
+        @midi.input.devices.concat(inputs)
+        @midi.input.channel = options[:receive_channel]
+      end
+
+    end
+
+    # Methods dealing with MIDI output
+    module Output
+
+      def self.included(base)
+        base.send(:extend, Forwardable)
+        base.send(:def_delegators, :@midi,
+                  :mute,
+                  :mute=,
+                  :output,
+                  :outputs,
+                  :toggle_mute,
+                  :tx_channel, 
+                  :transmit_channel,
+                  :tx_channel=,
+                  :transmit_channel=)
+      end
+
+      # Initialize MIDI output, enabling the sequencer to emit notes
+      # @param [Sequencer::Core] sequencer
+      # @return [Boolean]
+      def enable_output(sequencer)
+        sequencer.event.perform << proc do |bucket|
+          unless bucket.empty?
+            if @debug
+              bucket.each do |message|
+                puts "[DEBUG] MIDI: output #{message.name} channel: #{message.channel}"
+              end
+            end
+            @midi.output.puts(bucket)
+          end
+        end
+        sequencer.event.stop << proc { emit_pending_note_offs }
+        true
+      end
+
+      private
+
+      # Initialize MIDI output
+      # @param [Array<UniMIDI::Output>] outputs
+      # @param [Hash] options
+      # @option options [Fixnum] :tx_channel The transmit channel
+      def initialize_output(outputs, options = {})
+        @midi.output.devices.concat(outputs)
+        @midi.output.channel = options[:transmit_channel]
+      end
+
+    end
+
+    # An access point for dealing with all MIDI functionality for the instrument
+    class Node
+
+      include Input
+      include Output
+
+      # Initialize MIDI input and output
+      # @param [Hash] devices
+      # @param [Hash] options
+      # @option options [Fixnum] :channel The receive channel (also: :rx_channel)
+      # @option options [Fixnum] :tx_channel The transmit channel
+      def initialize(devices, options = {})
+        @debug = options.fetch(:debug, false)
+        @midi = MIDIInstrument::Node.new
+        initialize_input(devices[:input], options)
+        initialize_output(devices[:output], options)
+      end
+
+    end
+
+    # Shortcut to Diamond::MIDI::Node.new
+    def self.new(*args)
+      Node.new(*args)
+    end
+
+  end
+end

data/lib/diamond/osc.rb

@@ -0,0 +1,102 @@
+module Diamond
+
+  # Enable the instrument to use OSC
+  module OSC
+
+    # An access point for dealing with all OSC functionality for the instrument
+    class Node
+
+      # @param [Hash] options
+      # @option options [Boolean] :debug Whether to send debug output
+      # @option options [Fixnum] :server_port The port to listen on (default: 8000)
+      def initialize(options = {})
+        @debug = options.fetch(:debug, false)
+        port = options.fetch(:server_port, 8000)
+        @server = ::OSC::EMServer.new(port)
+      end
+
+      # Enable controlling the instrument via OSC
+      # @param [Object] subject The object to operate on when messages are received
+      # @param [Array<Hash>] map
+      # @return [Boolean]
+      def enable_parameter_control(subject, map)
+        start_server
+        maps = map.map do |item|
+          property = item[:property]
+          from_range = item[:value] || (0..1.0)
+          to_range = SequenceParameters::RANGE[property]
+          @server.add_method(item[:address]) do |message|
+            value = message.to_a[0]
+            value = Scale.transform(value).from(from_range).to(to_range)
+            puts "[DEBUG]: OSC: #{property}= #{value}" if @debug
+            subject.send("#{property}=", value)
+            true
+          end
+          true
+        end
+        maps.any?     
+      end
+
+      private
+
+      # Start the server
+      # @return [Thread]
+      def start_server
+        @thread = Thread.new do
+          begin
+            EM.epoll
+            EM.run { @server.run }
+          rescue Exception => exception
+            Thread.main.raise(exception)
+          end
+        end
+        @thread.abort_on_exception = true
+        @thread
+      end
+
+    end
+
+    # Shortcut to Diamond::OSC::Node.new
+    def self.new(*args)
+      Node.new(*args)
+    end
+
+  end
+end
+
+# Patch the OSC module
+#
+module OSC
+  class EMServer
+
+    def run
+      open
+    end
+
+    def open
+      EM::open_datagram_socket("0.0.0.0", @port, Connection)
+    end
+
+  end
+end
+
+module EventMachine
+  module WebSocket
+    def self.start(options, &blk)
+      #EM.epoll
+      #EM.run {
+        trap("TERM") { stop }
+        trap("INT")  { stop }
+
+        run(options, &blk)
+      #}
+    end
+
+    def self.run(options)
+      host, port = options.values_at(:host, :port)
+      EM.start_server(host, port, Connection, options) do |c|
+        yield c
+      end
+    end
+  end
+end

data/lib/diamond/pattern.rb

@@ -0,0 +1,95 @@
+module Diamond
+
+  # Pattern that the sequence is derived from given the parameters and input
+  class Pattern
+
+    module ClassMethods
+
+      # All patterns
+      # @return [Array<Pattern>]
+      def all
+        @patterns ||= []
+      end
+
+      # Find a pattern by its name (case insensitive)
+      # @param [String, Symbol] name
+      # @return [Pattern]
+      def find(name)
+        all.find { |pattern| pattern.name.to_s.downcase == name.to_s.downcase }
+      end
+
+      # Construct and add a pattern
+      # @param [Symbol, String] name
+      # @param [Proc] block
+      # @return [Array<Pattern>]
+      def add(*args, &block)
+        all << new(*args, &block)
+      end
+
+      # Add a pattern
+      # @param [Pattern] pattern
+      # @return [Array<Pattern>]
+      def <<(pattern)
+        all << pattern
+      end
+
+      # @return [Pattern]
+      def first
+        all.first
+      end
+
+      # @return [Pattern]
+      def last
+        all.last
+      end
+      
+    end
+
+    extend ClassMethods
+
+    attr_reader :name
+
+    # @param [String, Symbol] name A name to identify the pattern by eg "up/down"
+    # @param [Proc] block The pattern procedure, which should return an array of scale degree numbers.  
+    #                     For example, given the arguments (3, 7) the "Up" pattern will produce [0, 7, 14, 21]
+    def initialize(name, &block)
+      @name = name
+      @proc = block
+    end
+
+    # Compute scale degrees using the pattern with the given range and interval
+    # @param [Fixnum] range
+    # @param [Interval] interval
+    # @return [Array<Fixnum>]
+    def compute(range, interval)
+      @proc.call(range, interval)
+    end
+
+    # Standard preset patterns
+    module Presets
+
+      Pattern << Pattern.new("Up") do |range, interval|
+        0.upto(range).map { |num| num * interval }
+      end
+
+      Pattern << Pattern.new("Down") do |range, interval|
+        range.downto(0).map { |num| num * interval }
+      end
+
+      Pattern << Pattern.new("UpDown") do |range, interval|
+        up = 0.upto(range).map { |num| num * interval }
+        down = [(range - 1), 0].max.downto(0).map { |num| num * interval }
+        up + down
+      end
+
+      Pattern << Pattern.new("DownUp") do |range, interval|
+        down = range.downto(0).map { |num| num * interval }
+        up = 1.upto(range).map { |num| num * interval }
+        down + up
+      end
+
+    end
+
+  end
+
+end

data/lib/diamond/sequence.rb

@@ -0,0 +1,178 @@
+module Diamond
+
+  # The note event sequence from where the arpeggiator output is derived
+  class Sequence
+
+    extend Forwardable
+
+    def_delegators :@sequence, :each, :first, :last, :length
+
+    def initialize 
+      @parameter = nil
+      # realtime
+      @changed = false
+      @input_queue = []
+      @queue = []
+    end
+
+    # The bucket of messages for the given pointer
+    # @param [Fixnum] pointer
+    # @return [Array<MIDIMessage>]
+    def at(pointer)
+      if changed? && (pointer % @parameter.rate == 0)
+        update
+        @changed = false
+      end
+      enqueue_next(pointer)
+      messages = @queue.shift || []
+      messages
+    end
+
+    # Has the sequence changed since the last update?
+    # @return [Boolean]
+    def changed?
+      @changed
+    end
+
+    # Add inputted note_messages
+    # @param [Array<MIDIMessage::NoteOn>, MIDIMessage::NoteOn, *MIDIMessage::NoteOn] note_messages
+    # @return [Boolean]
+    def add(*note_messages)
+      messages = [note_messages].flatten.compact
+      @input_queue.concat(messages)
+      mark_changed
+      true
+    end
+
+    # Remove input note messages with the same note value
+    # @param [Array<MIDIMessage::NoteOn, MIDIMessage::NoteOff>, MIDIMessage::NoteOff, MIDIMessage::NoteOn, *MIDIMessage::NoteOff, *MIDIMessage::NoteOn] note_messages
+    # @return [Boolean]
+    def remove(*note_messages)
+      messages = [note_messages].flatten
+      deletion_queue = messages.map(&:note)
+      @input_queue.delete_if { |message| deletion_queue.include?(message.note) }
+      mark_changed
+      true
+    end
+
+    # Remove all input note messages
+    # @return [Boolean]
+    def remove_all
+      @input_queue.clear
+      mark_changed
+      true
+    end
+
+    # All NoteOff messages in the queue
+    # @return [Array<MIDIMessage::NoteOff>]
+    def pending_note_offs
+      messages = @queue.map do |bucket|
+        unless bucket.nil?
+          bucket.select { |m| m.class == MIDIMessage::NoteOff }       
+        end
+      end
+      messages.flatten.compact
+    end
+
+    # Mark the sequence as changed
+    # @return [Boolean]
+    def mark_changed
+      @changed = true
+    end
+
+    protected
+
+    # Apply the given parameters object
+    # @param [SequenceParameters] parameters
+    # @return [SequenceParameters]
+    def use_parameters(parameters)
+      @parameter = parameters
+      update
+    end
+
+    private
+
+    # Enqueue next bucket for the given pointer
+    # @param [Fixnum] pointer
+    # @return [Array<NoteEvent>]
+    def enqueue_next(pointer)
+      bucket = @sequence[pointer]
+      enqueue(bucket) unless bucket.nil?
+      bucket
+    end
+
+    # Prepare the given event bucket for performance, moving note messages to the queue
+    # @param [Array<NoteEvent>] bucket
+    # @return [Array<NoteEvent>]
+    def enqueue(bucket)
+      bucket.map do |event|
+        @queue[0] ||= []
+        @queue[0] << event.start 
+        float_length = (event.length.to_f / 100) * @parameter.duration.to_f
+        length = float_length.to_i
+        @queue[length] ||= []
+        @queue[length] << event.finish
+        event
+      end
+    end
+
+    # Commit changes to the sequence
+    # @return [ArpeggiatorSequence]
+    def update
+      notes = get_note_sequence
+      initialize_sequence(notes.length)
+      populate_sequence(notes) unless notes.empty?
+      @sequence
+    end
+
+    # (Re)initialize the sequence with the given length
+    # @param [Fixnum] length
+    # @return [Array]
+    def initialize_sequence(length)
+      sequence_length_in_ticks = length * @parameter.duration
+      @sequence = Array.new(sequence_length_in_ticks, [])
+    end
+
+    # Populate the sequence with the given notes
+    # @param [Array<MIDIMessage::NoteOn>] notes
+    # @return [Array<Array<NoteEvent>>]
+    def populate_sequence(notes)
+      @parameter.pattern_offset.times { notes.push(notes.shift) }
+      notes.each_with_index do |note, i| 
+        index = i * @parameter.duration
+        populate_bucket(index, note) unless @sequence[index].nil?
+      end
+      @sequence
+    end
+
+    # Populate the bucket for index with the given note message
+    # @param [Fixnum] index
+    # @param [MIDIMessage::NoteOn] note_message
+    # @return [Array<NoteEvent>]
+    def populate_bucket(index, note_message)
+      @sequence[index] = create_bucket(note_message)
+    end
+
+    # Create a bucket/note event for the given note message
+    # @param [MIDIMessage::NoteOn] note_message
+    # @return [Array<NoteEvent>]
+    def create_bucket(note_message)
+      event = MIDIInstrument::NoteEvent.new(note_message, @parameter.gate)
+      [event]
+    end
+
+    # The input queue as note messages
+    # @return [Array<MIDIMessage::NoteOn>]
+    def get_note_sequence
+      notes = @parameter.computed_pattern.map do |degree|
+        @input_queue.map do |message| 
+          note = message.note + degree + @parameter.transpose
+          MIDIMessage::NoteOn.new(message.channel, note, message.velocity)
+        end
+      end
+      notes.flatten.compact
+    end 
+
+  end
+
+end