musa-dsl 0.14.16

data/lib/musa-dsl/generative/variatio.rb

@@ -0,0 +1,331 @@
+require 'musa-dsl/core-ext/key-parameters-procedure-binder'
+require 'musa-dsl/core-ext/arrayfy'
+
+# TODO: permitir definir un variatio a través de llamadas a métodos y/o atributos, además de a través del block del constructor
+
+module Musa
+  class Variatio
+    def initialize(instance_name, &block)
+      raise ArgumentError, 'instance_name should be a symbol' unless instance_name.is_a?(Symbol)
+      raise ArgumentError, 'block is needed' unless block
+
+      @instance_name = instance_name
+
+      main_context = MainContext.new block
+
+      @constructor = main_context._constructor
+      @fieldset = main_context._fieldset
+      @finalize = main_context._finalize
+    end
+
+    def on(**values)
+      constructor_binder = KeyParametersProcedureBinder.new @constructor
+      finalize_binder = KeyParametersProcedureBinder.new @finalize if @finalize
+
+      run_fieldset = @fieldset.clone # TODO: verificar que esto no da problemas
+
+      run_fieldset.components.each do |component|
+        if values.key? component.name
+          component.options = values[component.name].arrayfy.explode_ranges
+        end
+      end
+
+      tree_A = generate_eval_tree_A run_fieldset
+      tree_B = generate_eval_tree_B run_fieldset
+
+      parameters_set = tree_A.calc_parameters
+
+      combinations = []
+
+      parameters_set.each do |parameters_with_depth|
+        instance = @constructor.call constructor_binder.apply(parameters_with_depth)
+
+        tree_B.run parameters_with_depth, @instance_name => instance
+
+        if @finalize
+          finalize_parameters = finalize_binder.apply parameters_with_depth
+          finalize_parameters[@instance_name] = instance
+
+          @finalize.call finalize_parameters
+        end
+
+        combinations << instance
+      end
+
+      combinations
+    end
+
+    def run
+      on
+    end
+
+    module Helper
+      module_function
+
+      def list_of_hashes_product(list_of_hashes_1, list_of_hashes_2)
+        result = []
+
+        list_of_hashes_1.each do |hash1|
+          list_of_hashes_2.each do |hash2|
+            result << hash1.merge(hash2)
+          end
+        end
+
+        result
+      end
+    end
+
+    private_constant :Helper
+
+    private
+
+    def generate_eval_tree_A(fieldset)
+      root = nil
+      current = nil
+
+      fieldset.components.each do |component|
+        if component.is_a? Field
+          a = A1.new component.name, component.options
+        elsif component.is_a? Fieldset
+          a = A2.new component.name, component.options, generate_eval_tree_A(component)
+        end
+
+        current.inner = a if current
+        root ||= a
+
+        current = a
+      end
+
+      root
+    end
+
+    def generate_eval_tree_B(fieldset)
+      affected_field_names = []
+      inner = []
+
+      fieldset.components.each do |component|
+        if component.is_a? Fieldset
+          inner << generate_eval_tree_B(component)
+        elsif component.is_a? Field
+          affected_field_names << component.name
+        end
+      end
+
+      B.new fieldset.name, fieldset.options, affected_field_names, inner, fieldset.with_attributes
+    end
+
+    class A
+      attr_reader :parameter_name, :options
+      attr_accessor :inner
+
+      def initialize(parameter_name, options)
+        @parameter_name = parameter_name
+        @options = options
+        @inner = nil
+      end
+
+      def calc_parameters
+        unless @calc_parameters
+          if inner
+            @calc_parameters = Helper.list_of_hashes_product(calc_own_parameters, @inner.calc_parameters)
+          else
+            @calc_parameters = calc_own_parameters
+          end
+        end
+
+        @calc_parameters
+      end
+    end
+
+    private_constant :A
+
+    class A1 < A
+      def initialize(parameter_name, options)
+        super parameter_name, options
+
+        @own_parameters = @options.collect { |option| { @parameter_name => option } }
+      end
+
+      def calc_own_parameters
+        @own_parameters
+      end
+
+      def inspect
+        "A1 name: #{@parameter_name}, options: #{@options}, inner: #{@inner || 'nil'}"
+      end
+
+      alias to_s inspect
+    end
+
+    private_constant :A1
+
+    class A2 < A
+      def initialize(parameter_name, options, subcomponent)
+        super parameter_name, options
+
+        @subcomponent = subcomponent
+
+        sub_parameters_set = @subcomponent.calc_parameters
+        result = nil
+
+        @options.each do |option|
+          if result.nil?
+            result = sub_parameters_set.collect { |v| { option => v } }
+          else
+            result = Helper.list_of_hashes_product result, sub_parameters_set.collect { |v| { option => v } }
+          end
+        end
+
+        result = result.collect { |v| { @parameter_name => v } }
+
+        @own_parameters = result
+      end
+
+      def calc_own_parameters
+        @own_parameters
+      end
+
+      def inspect
+        "A2 name: #{@parameter_name}, options: #{@options}, subcomponent: #{@subcomponent}, inner: #{@inner || 'nil'}"
+      end
+
+      alias to_s inspect
+    end
+
+    private_constant :A2
+
+    class B
+      attr_reader :parameter_name, :options, :affected_field_names, :blocks, :inner
+
+      def initialize(parameter_name, options, affected_field_names, inner, blocks)
+        @parameter_name = parameter_name
+        @options = options
+        @affected_field_names = affected_field_names
+        @inner = inner
+
+        @procedures = blocks.collect { |proc| KeyParametersProcedureBinder.new proc }
+      end
+
+      def run(parameters_with_depth, parent_parameters = nil)
+        parent_parameters ||= {}
+
+        @options.each do |option|
+          base = @parameter_name == :_maincontext ? parameters_with_depth : parameters_with_depth[@parameter_name][option]
+
+          parameters = base.select { |k, _v| @affected_field_names.include? k }.merge(parent_parameters)
+          parameters[@parameter_name] = option
+
+          @procedures.each do |procedure_binder|
+            procedure_binder.call parameters
+          end
+
+          if @parameter_name == :_maincontext
+            @inner.each do |inner|
+              inner.run parameters_with_depth, parameters
+            end
+          else
+            @inner.each do |inner|
+              inner.run parameters_with_depth[@parameter_name][option], parameters
+            end
+          end
+        end
+      end
+
+      def inspect
+        "B name: #{@parameter_name}, options: #{@options}, affected_field_names: #{@affected_field_names}, blocks_size: #{@blocks.size}, inner: #{@inner}"
+      end
+
+      alias to_s inspect
+
+      private
+    end
+
+    class FieldsetContext
+      attr_reader :_fieldset
+
+      def initialize(name, options = nil, block)
+        @_fieldset = Fieldset.new name, options.arrayfy.explode_ranges
+
+        _as_context_run block
+      end
+
+      def field(name, options = nil)
+        @_fieldset.components << Field.new(name, options.arrayfy.explode_ranges)
+      end
+
+      def fieldset(name, options = nil, &block)
+        fieldset_context = FieldsetContext.new name, options, block
+        @_fieldset.components << fieldset_context._fieldset
+      end
+
+      def with_attributes(&block)
+        @_fieldset.with_attributes << block
+      end
+    end
+
+    private_constant :FieldsetContext
+
+    class MainContext < FieldsetContext
+      attr_reader :_constructor, :_finalize
+
+      def initialize(block)
+        @_constructor = nil
+        @_finalize = nil
+
+        super :_maincontext, [nil], block
+      end
+
+      def constructor(&block)
+        @_constructor = block
+      end
+
+      def finalize(&block)
+        @_finalize = block
+      end
+    end
+
+    private_constant :MainContext
+
+    class Field
+      attr_reader :name
+      attr_accessor :options
+
+      def inspect
+        "Field #{@name} options: #{@options}"
+      end
+
+      alias to_s inspect
+
+      private
+
+      def initialize(name, options)
+        @name = name
+        @options = options
+      end
+    end
+
+    private_constant :Field
+
+    class Fieldset
+      attr_reader :name, :with_attributes, :components
+      attr_accessor :options
+
+      def inspect
+        "Fieldset #{@name} options: #{@options} components: #{@components}"
+      end
+
+      alias to_s inspect
+
+      private
+
+      def initialize(name, options)
+        @name = name
+        @options = options || [nil]
+        @components = []
+        @with_attributes = []
+      end
+    end
+
+    private_constant :Fieldset
+  end
+end

data/lib/musa-dsl/generative.rb

@@ -0,0 +1,5 @@
+require 'musa-dsl/generative/variatio'
+require 'musa-dsl/generative/darwin'
+require 'musa-dsl/generative/rules'
+require 'musa-dsl/generative/markov'
+require 'musa-dsl/generative/generative-grammar'

data/lib/musa-dsl/midi/midi-recorder.rb

@@ -0,0 +1,83 @@
+require 'nibbler'
+
+module Musa
+  class MIDIRecorder
+    def initialize(sequencer)
+      @sequencer = sequencer
+      @nibbler = Nibbler.new
+
+      clear
+    end
+
+    def clear
+      @messages = []
+    end
+
+    def record(midi_bytes)
+      m = @nibbler.parse midi_bytes
+      m = [m] unless m.is_a? Array
+
+      m.each do |mm|
+        @messages << Message.new(@sequencer.position, mm)
+      end
+    end
+
+    def raw
+      @messages
+    end
+
+    def transcription
+      note_on = {}
+      last_note = {}
+
+      notes = []
+
+      @messages.each do |m|
+        mm = m.message
+
+        if mm.is_a?(MIDIMessage::NoteOn)
+
+          if last_note[mm.channel]
+            notes << { position: last_note[mm.channel], channel: mm.channel, pitch: :silence, duration: m.position - last_note[mm.channel] }
+            last_note.delete mm.channel
+          end
+
+          note = { position: m.position, channel: mm.channel, pitch: mm.note, velocity: mm.velocity }
+
+          note_on[mm.channel] ||= {}
+          note_on[mm.channel][mm.note] = note
+
+          notes << note
+
+        elsif mm.is_a?(MIDIMessage::NoteOff)
+
+          note_on[mm.channel] ||= {}
+
+          note = note_on[mm.channel][mm.note]
+
+          if note
+            note_on[mm.channel].delete mm.note
+
+            note[:duration] = m.position - note[:position]
+            note[:velocity_off] = mm.velocity
+          end
+
+          last_note[mm.channel] = m.position
+        end
+      end
+
+      notes
+    end
+
+    class Message
+      attr_accessor :position, :message
+
+      def initialize(position, message)
+        @position = position
+        @message = message
+      end
+    end
+
+    private_constant :Message
+  end
+end

data/lib/musa-dsl/midi/midi-voices.rb

@@ -0,0 +1,274 @@
+require 'set'
+require 'midi-message'
+
+require 'musa-dsl/core-ext/array-apply-get'
+require 'musa-dsl/core-ext/arrayfy'
+
+module Musa
+  class MIDIVoices
+    attr_accessor :log
+
+    def initialize(sequencer:, output:, channels:, do_log: nil)
+      do_log ||= false
+
+      @sequencer = sequencer
+      @output = output
+      @channels = channels.arrayfy.explode_ranges
+      @do_log = do_log
+
+      reset
+    end
+
+    def reset
+      @voices = @channels.collect { |channel| MIDIVoice.new sequencer: @sequencer, output: @output, channel: channel, log: @do_log }.freeze
+    end
+
+    attr_reader :voices
+
+    def fast_forward=(enabled)
+      @voices.apply :fast_forward=, enabled
+    end
+
+    def panic(reset: nil)
+      reset ||= false
+
+      @voices.each(&:all_notes_off)
+
+      @output.puts MIDIMessage::SystemRealtime.new(0xff) if reset
+    end
+  end
+
+  private
+
+  class MIDIVoice
+    attr_accessor :name, :do_log
+    attr_reader :sequencer, :output, :channel, :active_pitches, :tick_duration
+
+    def initialize(sequencer:, output:, channel:, name: nil, log: nil)
+      log ||= false
+
+      @sequencer = sequencer
+      @output = output
+      @channel = channel
+      @name = name
+      @do_log = log
+
+      @tick_duration = Rational(1, @sequencer.ticks_per_bar)
+
+      @controllers_control = ControllersControl.new(@output, @channel)
+
+      @active_pitches = []
+      fill_active_pitches @active_pitches
+
+      log 'Warning: voice without output' unless @output
+
+      self
+    end
+
+    def fast_forward=(enabled)
+      if @fast_forward && !enabled
+        (0..127).each do |pitch|
+          @output.puts MIDIMessage::NoteOn.new(@channel, pitch, @active_pitches[pitch][:velocity]) unless @active_pitches[pitch][:note_controls].empty?
+        end
+      end
+
+      @fast_forward = enabled
+    end
+
+    def fast_forward?
+      @fast_forward
+    end
+
+    def note(pitchvalue = nil, pitch: nil, velocity: nil, duration: nil, duration_offset: nil, effective_duration: nil, velocity_off: nil)
+      pitch ||= pitchvalue
+
+      if pitch
+        velocity ||= 63
+
+        duration_offset ||= -@tick_duration
+        effective_duration ||= [0, duration + duration_offset].max
+
+        velocity_off ||= 63
+
+        NoteControl.new(self, pitch: pitch, velocity: velocity, duration: effective_duration, velocity_off: velocity_off).note_on
+      end
+    end
+
+    def controller
+      @controllers_control
+    end
+
+    def sustain_pedal=(value)
+      @controllers_control[:sustain_pedal] = value
+    end
+
+    def sustain_pedal
+      @controllers_control[:sustain_pedal]
+    end
+
+    def all_notes_off
+      @active_pitches.clear
+      fill_active_pitches @active_pitches
+
+      @output.puts MIDIMessage::ChannelMessage.new(0xb, @channel, 0x7b, 0)
+    end
+
+    def log(msg)
+      @sequencer.log "voice #{name || @channel}: #{msg}" if @do_log
+    end
+
+    def to_s
+      "voice #{@name} output: #{@output} channel: #{@channel}"
+      end
+
+    private
+
+    def fill_active_pitches(pitches)
+      (0..127).each do |pitch|
+        pitches[pitch] = { note_controls: Set[], velocity: 0 }
+      end
+    end
+
+    class ControllersControl
+      def initialize(output, channel)
+        @output = output
+        @channel = channel
+
+        @controller_map = { sustain_pedal: 0x40 }
+        @controller = []
+      end
+
+      def []=(controller_number_or_symbol, value)
+        number = number_of(controller_number_or_symbol)
+        value ||= 0
+
+        @controller[number] = [[0, value].max, 0xff].min
+        @output.puts MIDIMessage::ChannelMessage.new(0xb, @channel, number, @controller[number])
+      end
+
+      def [](controller_number_or_symbol)
+        @controller[number_of(controller_number_or_symbol)]
+      end
+
+      def number_of(controller_number_or_symbol)
+        case controller_number_or_symbol
+        when Numeric
+          controller_number_or_symbol.to_i
+        when Symbol
+          @controller_map[controller_number_or_symbol]
+        else
+          raise ArgumentError, "#{controller_number_or_symbol} is not a Numeric nor a Symbol. Only MIDI controller numbers are allowed"
+        end
+      end
+    end
+
+    private_constant :ControllersControl
+
+    class NoteControl
+      attr_reader :start_position, :end_position
+
+      def initialize(voice, pitch:, velocity: nil, duration: nil, velocity_off: nil)
+        raise ArgumentError, "MIDIVoice: note duration should be nil or Numeric: #{duration} (#{duration.class})" unless duration.nil? || duration.is_a?(Numeric)
+
+        @voice = voice
+
+        @pitch = pitch.arrayfy.explode_ranges
+
+        @velocity = velocity.arrayfy.explode_ranges
+        @velocity_off = velocity_off.arrayfy.explode_ranges
+
+        @duration = duration
+
+        @do_on_stop = []
+        @do_after = []
+
+        @start_position = @end_position = nil
+      end
+
+      def note_on
+        @start_position = @voice.sequencer.position
+        @end_position = nil
+
+        @pitch.each_index do |i|
+          pitch = @pitch[i]
+          velocity = @velocity[i % @velocity.size]
+
+          if !silence?(pitch)
+            @voice.active_pitches[pitch][:note_controls] << self
+            @voice.active_pitches[pitch][:velocity] = velocity
+
+            msg = MIDIMessage::NoteOn.new(@voice.channel, pitch, velocity)
+            @voice.log "#{msg.verbose_name} velocity: #{velocity} duration: #{@duration}"
+            @voice.output.puts msg if @voice.output && !@voice.fast_forward?
+          else
+            @voice.log "silence duration: #{@duration}"
+          end
+        end
+
+        return self unless @duration
+
+        this = self
+        @voice.sequencer.wait @duration do
+          this.note_off velocity: @velocity_off
+        end
+
+        self
+      end
+
+      def note_off(velocity: nil)
+        velocity ||= @velocity_off
+
+        velocity = velocity.arrayfy.explode_ranges
+
+        @pitch.each_index do |i|
+          pitch = @pitch[i]
+          velocity_off = velocity[i % velocity.size]
+
+          next if silence?(pitch)
+
+          @voice.active_pitches[pitch][:note_controls].delete self
+
+          next unless @voice.active_pitches[pitch][:note_controls].empty?
+
+          msg = MIDIMessage::NoteOff.new(@voice.channel, pitch, velocity_off)
+          @voice.log msg.verbose_name.to_s
+          @voice.output.puts msg if @voice.output && !@voice.fast_forward?
+        end
+
+        @end_position = @voice.sequencer.position
+
+        @do_on_stop.each do |do_on_stop|
+          @voice.sequencer.wait 0, &do_on_stop
+        end
+
+        @do_after.each do |do_after|
+          @voice.sequencer.wait @voice.tick_duration + do_after[:bars], &do_after[:block]
+        end
+
+        nil
+      end
+
+      def active?
+        @start_position && !@end_position
+      end
+
+      def on_stop(&block)
+        @do_on_stop << block
+        nil
+      end
+
+      def after(bars = 0, &block)
+        @do_after << { bars: bars.rationalize, block: block }
+        nil
+      end
+
+      private
+
+      def silence?(pitch)
+        pitch.nil? || pitch == :silence
+      end
+    end
+
+    private_constant :NoteControl
+  end
+end

data/lib/musa-dsl/midi.rb

@@ -0,0 +1,2 @@
+require 'musa-dsl/midi/midi-voices'
+require 'musa-dsl/midi/midi-recorder'