musa-dsl 0.14.31 → 0.21.4

data/lib/musa-dsl/sequencer/base-sequencer-public.rb

@@ -1,251 +1,273 @@
-require 'musa-dsl/core-ext/arrayfy'
-require 'musa-dsl/core-ext/key-parameters-procedure-binder'
+require_relative '../core-ext/arrayfy'
+require_relative '../core-ext/smart-proc-binder'
+require_relative '../logger'
 
-require 'musa-dsl/series'
+require_relative '../series'
 
-class Musa::BaseSequencer
-  attr_reader :beats_per_bar, :ticks_per_beat, :ticks_per_bar, :tick_duration, :running_position
-  attr_reader :everying, :playing, :moving
+require_relative 'timeslots'
 
-  @@tick_mutex = Mutex.new
+require_relative 'base-sequencer-tick-based'
+require_relative 'base-sequencer-tickless-based'
 
-  def initialize(beats_per_bar, ticks_per_beat, do_log: nil)
-    do_log ||= false
+module Musa
+  module Sequencer
+    class BaseSequencer
+      attr_reader :beats_per_bar, :ticks_per_beat
+      attr_reader :running_position
+      attr_reader :everying, :playing, :moving
+      attr_reader :logger
 
-    @on_debug_at = []
-    @on_block_error = []
+      def initialize(beats_per_bar = nil, ticks_per_beat = nil, logger: nil, do_log: nil, do_error_log: nil, log_position_format: nil)
 
-    @before_tick = []
-    @on_fast_forward = []
+        raise ArgumentError,
+              "'beats_per_bar' and 'ticks_per_beat' parameters should be both nil or both have values" \
+              unless beats_per_bar && ticks_per_beat || beats_per_bar.nil? && ticks_per_beat.nil?
 
-    @beats_per_bar = Rational(beats_per_bar)
-    @ticks_per_beat = Rational(ticks_per_beat)
+        if logger
+          @logger = logger
+        else
+          @logger = Musa::Logger::Logger.new(sequencer: self, position_format: log_position_format)
 
-    @ticks_per_bar = Rational(beats_per_bar * ticks_per_beat)
-    @tick_duration = Rational(1, @ticks_per_bar)
+          @logger.error! if do_error_log || do_error_log.nil?
+          @logger.debug! if do_log
+        end
 
-    @position_mutex = Mutex.new
-    @hold_public_ticks = false
-    @hold_ticks = 0
+        if beats_per_bar && ticks_per_beat
+          @beats_per_bar = Rational(beats_per_bar)
+          @ticks_per_beat = Rational(ticks_per_beat)
 
-    @score = {}
+          self.singleton_class.include TickBasedTiming
+        else
+          self.singleton_class.include TicklessBasedTiming
+        end
 
-    @everying = []
-    @playing = []
-    @moving = []
+        _init_timing
 
-    @do_log = do_log
+        @on_debug_at = []
+        @on_error = []
 
-    reset
-  end
+        @before_tick = []
+        @on_fast_forward = []
 
-  def reset
-    @score.clear
-    @everying.clear
-    @playing.clear
-    @moving.clear
+        @tick_mutex = Mutex.new
+        @position_mutex = Mutex.new
 
-    @event_handlers = [EventHandler.new]
+        @timeslots = Timeslots.new
 
-    @position = @position_mutex.synchronize { @ticks_per_bar - 1 }
-  end
+        @everying = []
+        @playing = []
+        @moving = []
 
-  def tick
-    if @hold_public_ticks
-      @hold_ticks += 1
-    else
-      _tick
-    end
-  end
+        reset
+      end
 
-  def size
-    @score.size
-  end
+      def reset
+        @timeslots.clear
+        @everying.clear
+        @playing.clear
+        @moving.clear
 
-  def empty?
-    @score.empty?
-  end
+        @event_handlers = [EventHandler.new]
 
-  def round(bar)
-    Rational((bar * @ticks_per_bar).round(0), @ticks_per_bar)
-  end
+        _reset_timing
+      end
 
-  def event_handler
-    @event_handlers.last
-  end
+      def size
+        @timeslots.values.sum(&:size)
+      end
 
-  def on_debug_at(&block)
-    @on_debug_at << KeyParametersProcedureBinder.new(block)
-  end
+      def empty?
+        @timeslots.empty?
+      end
 
-  def on_block_error(&block)
-    @on_block_error << KeyParametersProcedureBinder.new(block)
-  end
-
-  def on_fast_forward(&block)
-    @on_fast_forward << KeyParametersProcedureBinder.new(block)
-  end
+      def run
+        tick until empty?
+      end
 
-  def before_tick(&block)
-    @before_tick << KeyParametersProcedureBinder.new(block)
-  end
+      def event_handler
+        @event_handlers.last
+      end
 
-  def position
-    Rational(@position, @ticks_per_bar)
-  end
+      def on_debug_at(&block)
+        @on_debug_at << SmartProcBinder.new(block)
+      end
 
-  def position=(bposition)
-    position = bposition * @ticks_per_bar
+      def on_error(&block)
+        @on_error << SmartProcBinder.new(block)
+      end
 
-    raise ArgumentError, "Sequencer #{self}: cannot move back. current position: #{@position} new position: #{position}" if position < @position
+      def on_fast_forward(&block)
+        @on_fast_forward << SmartProcBinder.new(block)
+      end
 
-    _hold_public_ticks
-    @on_fast_forward.each { |block| block.call(true) }
+      def before_tick(&block)
+        @before_tick << SmartProcBinder.new(block)
+      end
 
-    _tick while @position < position
+      def on(event, &block)
+        @event_handlers.last.on event, &block
+      end
 
-    @on_fast_forward.each { |block| block.call(false) }
-    _release_public_ticks
-  end
+      def launch(event, *value_parameters, **key_parameters)
+        @event_handlers.last.launch event, *value_parameters, **key_parameters
+      end
 
-  def on(event, &block)
-    @event_handlers.last.on event, &block
-  end
+      def wait(bars_delay, with: nil, debug: nil, &block)
+        debug ||= false
 
-  def launch(event, *value_parameters, **key_parameters)
-    @event_handlers.last.launch event, *value_parameters, **key_parameters
-  end
+        control = EventHandler.new @event_handlers.last
+        @event_handlers.push control
 
-  def wait(bars_delay, with: nil, debug: nil, &block)
-    debug ||= false
+        if bars_delay.is_a? Numeric
+          _numeric_at position + bars_delay.rationalize, control, with: with, debug: debug, &block
+        else
+          bars_delay = Series::S(*bars_delay) if bars_delay.is_a?(Array)
+          bars_delay = bars_delay.instance if bars_delay
 
-    control = EventHandler.new @event_handlers.last, capture_stdout: true
-    @event_handlers.push control
+          with = Series::S(*with).repeat if with.is_a?(Array)
+          with = with.instance if with
 
-    if bars_delay.is_a? Numeric
-      _numeric_at position + bars_delay.rationalize, control, with: with, debug: debug, &block
-    else
-      bars_delay = Series::S(*bars_delay) if bars_delay.is_a? Array
-      bars_delay = bars_delay.instance if bars_delay
+          _serie_at bars_delay.eval { |delay| position + delay }, control, with: with, debug: debug, &block
+        end
 
-      with = Series::S(*with).repeat if with.is_a? Array
-      with = with.instance if with
+        @event_handlers.pop
 
-      _serie_at bars_delay.eval { |delay| position + delay }, control, with: with, debug: debug, &block
-    end
+        control
+      end
 
-    @event_handlers.pop
+      def now(with: nil, &block)
+        control = EventHandler.new @event_handlers.last
+        @event_handlers.push control
 
-    control
-  end
+        _numeric_at position, control, with: with, &block
 
-  def now(with: nil, &block)
-    control = EventHandler.new @event_handlers.last, capture_stdout: true
-    @event_handlers.push control
+        @event_handlers.pop
 
-    _numeric_at position, control, with: with, &block
+        control
+      end
 
-    @event_handlers.pop
+      def raw_at(bar_position, force_first: nil, &block)
+        _raw_numeric_at bar_position.rationalize, force_first: force_first, &block
 
-    control
-  end
+        nil
+      end
 
-  def raw_at(bar_position, force_first: nil, &block)
-    _raw_numeric_at bar_position, force_first: force_first, &block
+      def at(bar_position, with: nil, debug: nil, &block)
+        debug ||= false
 
-    nil
-  end
+        control = EventHandler.new @event_handlers.last
+        @event_handlers.push control
 
-  def at(bar_position, with: nil, debug: nil, &block)
-    debug ||= false
+        if bar_position.is_a? Numeric
+          _numeric_at bar_position.rationalize, control, with: with, debug: debug, &block
+        else
+          bar_position = Series::S(*bar_position) if bar_position.is_a? Array
+          bar_position = bar_position.instance if bar_position
 
-    control = EventHandler.new @event_handlers.last, capture_stdout: true
-    @event_handlers.push control
+          with = Series::S(*with).repeat if with.is_a? Array
+          with = with.instance if with
 
-    if bar_position.is_a? Numeric
-      _numeric_at bar_position, control, with: with, debug: debug, &block
-    else
-      bar_position = Series::S(*bar_position) if bar_position.is_a? Array
-      bar_position = bar_position.instance if bar_position
+          _serie_at bar_position, control, with: with, debug: debug, &block
+        end
 
-      with = Series::S(*with).repeat if with.is_a? Array
-      with = with.instance if with
+        @event_handlers.pop
 
-      _serie_at bar_position, control, with: with, debug: debug, &block
-    end
+        control
+      end
 
-    @event_handlers.pop
+      def play(serie, mode: nil, parameter: nil, after: nil, context: nil, **mode_args, &block)
+        mode ||= :wait
 
-    control
-  end
+        control = PlayControl.new @event_handlers.last, after: after
+        @event_handlers.push control
 
-  def play(serie, mode: nil, parameter: nil, after: nil, context: nil, **mode_args, &block)
-    mode ||= :wait
+        _play serie.instance, control, context, mode: mode, parameter: parameter, **mode_args, &block
 
-    control = PlayControl.new @event_handlers.last, after: after, capture_stdout: true
-    @event_handlers.push control
+        @event_handlers.pop
 
-    _play serie.instance, control, context, mode: mode, parameter: parameter, **mode_args, &block
+        @playing << control
 
-    @event_handlers.pop
+        control.after do
+          @playing.delete control
+        end
 
-    @playing << control
+        control
+      end
 
-    control.after do
-      @playing.delete control
-    end
+      def continuation_play(parameters)
+        _play parameters[:serie],
+              parameters[:control],
+              parameters[:nl_context],
+              mode: parameters[:mode],
+              decoder: parameters[:decoder],
+              __play_eval: parameters[:play_eval],
+              **parameters[:mode_args]
+      end
 
-    control
-  end
+      def every(interval, duration: nil, till: nil, condition: nil, on_stop: nil, after_bars: nil, after: nil, &block)
+        # nil interval means 'only once'
+        interval = interval.rationalize unless interval.nil?
 
-  def continuation_play(parameters)
-    _play parameters[:serie],
-          parameters[:control],
-          parameters[:nl_context],
-          mode: parameters[:mode],
-          decoder: parameters[:decoder],
-          __play_eval: parameters[:play_eval],
-          **parameters[:mode_args]
-  end
+        control = EveryControl.new @event_handlers.last,
+                                   duration: duration,
+                                   till: till,
+                                   condition: condition,
+                                   on_stop: on_stop,
+                                   after_bars: after_bars,
+                                   after: after
 
-  def every(binterval, duration: nil, till: nil, condition: nil, on_stop: nil, after_bars: nil, after: nil, &block)
-    binterval = binterval.rationalize
+        @event_handlers.push control
 
-    control = EveryControl.new @event_handlers.last, capture_stdout: true, duration: duration, till: till, condition: condition, on_stop: on_stop, after_bars: after_bars, after: after
-    @event_handlers.push control
+        _every interval, control, &block
 
-    _every binterval, control, &block
+        @event_handlers.pop
 
-    @event_handlers.pop
+        @everying << control
 
-    @everying << control
+        control.after do
+          @everying.delete control
+        end
 
-    control.after do
-      @everying.delete control
-    end
+        control
+      end
 
-    control
-  end
+      def move(every: nil,
+               from: nil, to: nil, step: nil,
+               duration: nil, till: nil,
+               function: nil,
+               right_open: nil,
+               on_stop: nil,
+               after_bars: nil,
+               after: nil,
+               &block)
 
-  def move(every: nil, from: nil, to: nil, step: nil, duration: nil, till: nil, right_open: nil, on_stop: nil, after_bars: nil, after: nil, &block)
-    control = _move every: every, from: from, to: to, step: step, duration: duration, till: till, right_open: right_open, on_stop: on_stop, after_bars: after_bars, after: after, &block
+        control = _move every: every,
+                        from: from, to: to, step: step,
+                        duration: duration, till: till,
+                        function: function,
+                        right_open: right_open,
+                        on_stop: on_stop,
+                        after_bars: after_bars,
+                        after: after,
+                        &block
 
-    @moving << control
+        @moving << control
 
-    control.after do
-      @moving.delete control
-    end
+        control.after do
+          @moving.delete control
+        end
 
-    control
-  end
+        control
+      end
 
-  def log(msg = nil)
-    _log msg
-  end
+      def debug(msg = nil)
+        @logger.debug { msg || '...' }
+      end
 
-  def inspect
-    super + ": position=#{position}"
+      def to_s
+        super + ": position=#{position}"
+      end
+    end
   end
-
-  alias to_s inspect
 end
+

data/lib/musa-dsl/sequencer/base-sequencer-tick-based.rb

@@ -0,0 +1,75 @@
+module Musa
+  module Sequencer
+    class BaseSequencer
+      module TickBasedTiming
+
+        attr_reader :position, :ticks_per_bar, :tick_duration
+
+        def tick
+          if @hold_public_ticks
+            @hold_ticks += 1
+          else
+            _tick @position_mutex.synchronize { @position += @tick_duration }
+          end
+        end
+
+        def position=(new_position)
+          raise ArgumentError,
+                "Sequencer #{self}: cannot move back. current position: #{@position} new position: #{new_position}" \
+                  if new_position < position
+
+          _hold_public_ticks
+          @on_fast_forward.each { |block| block.call(true) }
+
+          _tick(@position_mutex.synchronize { @position += @tick_duration }) while @position < new_position
+
+          @on_fast_forward.each { |block| block.call(false) }
+          _release_public_ticks
+        end
+
+        private
+
+        def _init_timing
+          @ticks_per_bar = Rational(beats_per_bar * ticks_per_beat)
+          @tick_duration = Rational(1, @ticks_per_bar)
+
+          @hold_public_ticks = false
+          @hold_ticks = 0
+        end
+
+        def _reset_timing
+          @position = @position_mutex.synchronize { 1r - @tick_duration }
+        end
+
+        def _check_position(position)
+          ticks_position = position / @tick_duration
+
+          if ticks_position.round != ticks_position
+            original_position = position
+            position = ticks_position.round * @tick_duration
+
+            @logger.warn('BaseSequencer') { "._numeric_at: warning: rounding "\
+                "position #{position} (#{original_position.to_f.round(5)}) "\
+                "to tick precision: #{position} (#{position.to_f.round(5)})" }
+          end
+
+          position
+        end
+
+        def _quantize(position)
+          (position / @tick_duration).round * @tick_duration
+        end
+
+        def _hold_public_ticks
+          @hold_public_ticks = true
+        end
+
+        def _release_public_ticks
+          @hold_ticks.times { _tick(@position_mutex.synchronize { @position += @tick_duration }) }
+          @hold_ticks = 0
+          @hold_public_ticks = false
+        end
+      end
+    end
+  end
+end