cyclotone 0.1.0

data/lib/cyclotone/stream.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "set"
+
+module Cyclotone
+  class Stream
+    include Singleton
+    include Transition
+
+    attr_reader :scheduler
+
+    def initialize
+      @slots = {}
+      @muted = Set.new
+      @soloed = Set.new
+      @scheduler = Scheduler.new(backend: Backends::OSCBackend.new(socket: UDPSocket.new))
+    rescue StandardError
+      @scheduler = Scheduler.new(backend: NullBackend.new)
+    end
+
+    def d(slot_id, pattern)
+      assign(normalize_d_slot_id(slot_id), pattern)
+    end
+
+    def p(name, pattern)
+      assign(normalize_slot_reference(name), pattern)
+    end
+
+    def hush
+      @slots.keys.each { |slot_id| assign(slot_id, Pattern.silence) }
+      self
+    end
+
+    def solo(id)
+      @soloed << normalize_slot_reference(id)
+      sync_scheduler
+    end
+
+    def unsolo(id)
+      @soloed.delete(normalize_slot_reference(id))
+      sync_scheduler
+    end
+
+    def mute(id)
+      @muted << normalize_slot_reference(id)
+      sync_scheduler
+    end
+
+    def unmute(id)
+      @muted.delete(normalize_slot_reference(id))
+      sync_scheduler
+    end
+
+    def setcps(value)
+      @scheduler.setcps(value)
+      self
+    end
+
+    def reset_cycles
+      @scheduler.reset_cycles
+      self
+    end
+
+    def set_cycle(value)
+      @scheduler.set_cycle(value)
+      self
+    end
+
+    def use_backend(backend)
+      @scheduler.backend = backend
+      sync_scheduler
+    end
+
+    def start
+      @scheduler.start
+      self
+    end
+
+    def stop
+      @scheduler.stop
+      self
+    end
+
+    def running?
+      @scheduler.running?
+    end
+
+    def trigger
+      wait_until_cycle(@scheduler.current_cycle + (@scheduler.interval * @scheduler.cps))
+    end
+
+    def qtrigger
+      wait_until_cycle(@scheduler.current_cycle.ceil)
+    end
+
+    def mtrigger(period)
+      normalized_period = [period.to_i, 1].max
+      current_cycle = @scheduler.current_cycle
+      next_cycle = current_cycle.ceil
+      remainder = next_cycle % normalized_period
+      target_cycle = remainder.zero? ? next_cycle : next_cycle + (normalized_period - remainder)
+
+      wait_until_cycle(target_cycle)
+    end
+
+    def slot(slot_id)
+      @slots[normalize_slot_reference(slot_id)]
+    end
+
+    private
+
+    def assign(slot_id, pattern)
+      @slots[slot_id] = normalize_pattern(pattern)
+      sync_scheduler
+      @slots[slot_id]
+    end
+
+    def normalize_pattern(pattern)
+      return pattern if pattern.is_a?(Pattern)
+      return Pattern.mn(pattern) if pattern.is_a?(String)
+
+      Pattern.pure(pattern)
+    end
+
+    def normalize_d_slot_id(slot_id)
+      raw = slot_id.to_s
+      return raw.to_sym if raw.match?(/\Ad\d+\z/)
+      return :"d#{raw}" if raw.match?(/\A\d+\z/)
+
+      :"d#{raw}"
+    end
+
+    def normalize_slot_reference(slot_id)
+      raw = slot_id.to_s
+      return raw.to_sym if raw.match?(/\Ad\d+\z/)
+      return :"d#{raw}" if raw.match?(/\A\d+\z/)
+
+      raw.to_sym
+    end
+
+    def sync_scheduler
+      active_slots.each do |slot_id, pattern|
+        @scheduler.update_pattern(slot_id, pattern)
+      end
+
+      inactive_slots.each do |slot_id|
+        @scheduler.remove_pattern(slot_id)
+      end
+
+      self
+    end
+
+    def active_slots
+      if @soloed.empty?
+        @slots.reject { |slot_id, _| @muted.include?(slot_id) }
+      else
+        @slots.select { |slot_id, _| @soloed.include?(slot_id) && !@muted.include?(slot_id) }
+      end
+    end
+
+    def inactive_slots
+      @slots.keys - active_slots.keys
+    end
+
+    def wait_until_cycle(target_cycle)
+      cycles_remaining = target_cycle.to_f - @scheduler.current_cycle
+      seconds = cycles_remaining / @scheduler.cps
+      sleep(seconds) if seconds.positive?
+      self
+    end
+
+    class NullBackend
+      attr_reader :events
+
+      def initialize
+        @events = []
+      end
+
+      def send_event(event, at:, **options)
+        @events << { event: event, at: at, options: options }
+      end
+    end
+  end
+end

data/lib/cyclotone/support/deterministic.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  module Support
+    module Deterministic
+      module_function
+
+      def seed_for(*parts)
+        parts.flatten.compact.reduce(17) do |memo, part|
+          ((memo * 31) ^ normalize(part).hash) & 0xFFFFFFFF
+        end
+      end
+
+      def random(*parts)
+        Random.new(seed_for(*parts))
+      end
+
+      def float(*parts)
+        random(*parts).rand
+      end
+
+      def int(max, *parts)
+        return 0 if max.to_i <= 0
+
+        random(*parts).rand(max.to_i)
+      end
+
+      private_class_method def self.normalize(value)
+        case value
+        when Rational
+          [value.numerator, value.denominator]
+        when Array
+          value.map { |entry| normalize(entry) }
+        when Hash
+          value.sort_by { |key, _| key.to_s }.map { |key, item| [key, normalize(item)] }
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/cyclotone/time_span.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  class TimeSpan
+    attr_reader :start, :stop
+
+    def initialize(start_time, stop_time)
+      @start = coerce_time(start_time)
+      @stop = coerce_time(stop_time)
+
+      raise ArgumentError, "stop time must be greater than or equal to start time" if @stop < @start
+
+      freeze
+    end
+
+    def duration
+      stop - start
+    end
+
+    def midpoint
+      (start + stop) / 2
+    end
+
+    def cycle_number
+      start.floor
+    end
+
+    def intersection(other)
+      intersection_start = [start, other.start].max
+      intersection_stop = [stop, other.stop].min
+
+      return nil if intersection_start >= intersection_stop
+
+      self.class.new(intersection_start, intersection_stop)
+    end
+
+    def includes?(time)
+      normalized_time = coerce_time(time)
+      start <= normalized_time && normalized_time < stop
+    end
+
+    def cycle_spans
+      return [] if duration.zero?
+
+      spans = []
+      current_start = start
+
+      while current_start < stop
+        cycle_boundary = [Rational(current_start.floor + 1), stop].min
+        spans << self.class.new(current_start, cycle_boundary)
+        current_start = cycle_boundary
+      end
+
+      spans
+    end
+
+    def shift(amount)
+      normalized_amount = coerce_time(amount)
+
+      self.class.new(start + normalized_amount, stop + normalized_amount)
+    end
+
+    def scale(factor)
+      normalized_factor = coerce_time(factor)
+
+      self.class.new(start * normalized_factor, stop * normalized_factor)
+    end
+
+    def reverse_within(cycle_start, cycle_length = 1)
+      normalized_start = coerce_time(cycle_start)
+      normalized_length = coerce_time(cycle_length)
+      mirror = (normalized_start * 2) + normalized_length
+
+      self.class.new(mirror - stop, mirror - start)
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && start == other.start && stop == other.stop
+    end
+
+    alias eql? ==
+
+    def hash
+      [self.class, start, stop].hash
+    end
+
+    def to_s
+      "[#{start}, #{stop})"
+    end
+
+    private
+
+    def coerce_time(value)
+      return value if value.is_a?(Rational)
+
+      Rational(value)
+    end
+  end
+end

data/lib/cyclotone/transforms/accumulation.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  module Transforms
+    module Accumulation
+      def overlay(other)
+        Pattern.stack([self, Pattern.ensure_pattern(other)])
+      end
+
+      def superimpose(&block)
+        overlay(block.call(self))
+      end
+
+      def layer(functions)
+        Pattern.stack(functions.map { |function| function.call(self) })
+      end
+
+      def jux(&block)
+        jux_by(1, &block)
+      end
+
+      def jux_by(amount, &block)
+        left = merge(Controls.pan(0.5 - (amount.to_f / 2.0)))
+        right = block.call(self).merge(Controls.pan(0.5 + (amount.to_f / 2.0)))
+        Pattern.stack([left, right])
+      end
+
+      def weave(count, pattern, controls)
+        functions = Array(controls).map do |control_pattern|
+          proc { |base| base.merge(control_pattern) }
+        end
+
+        weave_with(count, pattern, functions)
+      end
+
+      def weave_with(count, pattern, functions)
+        Pattern.fastcat(
+          Array.new(count) do |index|
+            functions[index % functions.length].call(pattern)
+          end
+        )
+      end
+    end
+  end
+end

data/lib/cyclotone/transforms/alteration.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  module Transforms
+    module Alteration
+      def every(period, &block)
+        every_with_offset(period, 0, &block)
+      end
+
+      def every_with_offset(period, offset, &block)
+        Pattern.new do |span|
+          if ((span.cycle_number - offset) % period).zero?
+            block.call(self).query_span(span)
+          else
+            query_span(span)
+          end
+        end
+      end
+
+      def fold_every(periods, &block)
+        Array(periods).reduce(self) do |pattern, period|
+          pattern.every(period, &block)
+        end
+      end
+
+      def sometimes(&block)
+        sometimes_by(0.5, &block)
+      end
+
+      def sometimes_by(probability, &block)
+        Pattern.new do |span|
+          if Support::Deterministic.float(:sometimes, probability, span.cycle_number) < probability.to_f
+            block.call(self).query_span(span)
+          else
+            query_span(span)
+          end
+        end
+      end
+
+      def rarely(&block)
+        sometimes_by(0.25, &block)
+      end
+
+      def almost_always(&block)
+        sometimes_by(0.9, &block)
+      end
+
+      def almost_never(&block)
+        sometimes_by(0.1, &block)
+      end
+
+      def chunk(count, &block)
+        Pattern.new do |span|
+          selected = span.cycle_number % count
+          pieces = Array.new(count) do |index|
+            segment = zoom(Rational(index, count), Rational(index + 1, count))
+            index == selected ? block.call(segment) : segment
+          end
+
+          Pattern.fastcat(pieces).query_span(span)
+        end
+      end
+
+      def scramble(count)
+        reorder_segments(count) do |cycle|
+          Array.new(count) { |index| index }.shuffle(random: Support::Deterministic.random(:scramble, cycle))
+        end
+      end
+
+      def shuffle(count)
+        scramble(count)
+      end
+
+      def iter(count)
+        reorder_segments(count) do |cycle|
+          Array.new(count) { |index| (index + cycle) % count }
+        end
+      end
+
+      def iter_back(count)
+        reorder_segments(count) do |cycle|
+          Array.new(count) { |index| (index - cycle) % count }
+        end
+      end
+
+      def degrade_by(probability)
+        select_events do |event|
+          cycle = (event.onset || event.part.start).floor
+          seed = [:degrade, probability, cycle, event.value, event.part.start]
+          Support::Deterministic.float(seed) >= probability.to_f
+        end
+      end
+
+      def degrade
+        degrade_by(0.5)
+      end
+
+      def trunc(amount)
+        limit = Pattern.to_rational(amount)
+
+        Pattern.new do |span|
+          cycle_start = Rational(span.cycle_number)
+          allowed = TimeSpan.new(cycle_start, cycle_start + limit)
+          overlap = span.intersection(allowed)
+          next [] unless overlap
+
+          query_span(overlap).map do |event|
+            clipped_part = event.part.intersection(allowed)
+            next unless clipped_part
+
+            clipped_whole = event.whole&.intersection(allowed) || event.whole
+
+            event.with_span(new_whole: clipped_whole, new_part: clipped_part)
+          end.compact
+        end
+      end
+
+      def linger(amount)
+        zoom(0, amount)
+      end
+
+      def zoom(start_point, end_point)
+        window_start = Pattern.to_rational(start_point)
+        window_end = Pattern.to_rational(end_point)
+        window_length = window_end - window_start
+
+        Pattern.new do |span|
+          cycle_start = Rational(span.cycle_number)
+          source_span = TimeSpan.new(
+            cycle_start + window_start + ((span.start - cycle_start) * window_length),
+            cycle_start + window_start + ((span.stop - cycle_start) * window_length)
+          )
+
+          query_span(source_span).map do |event|
+            Pattern.map_event(event) do |time|
+              cycle_start + ((time - cycle_start - window_start) / window_length)
+            end
+          end
+        end
+      end
+
+      def stripe(count)
+        fast(count)
+      end
+
+      def slowstripe(count)
+        slow(count)
+      end
+
+      def spread(function, values)
+        sequence = Pattern.cat(Array(values).map { |value| function.call(self, value) })
+        Pattern.new { |span| sequence.query_span(span) }
+      end
+
+      def fastspread(function, values)
+        Pattern.fastcat(Array(values).map { |value| function.call(self, value) })
+      end
+
+      private
+
+      def reorder_segments(count)
+        Pattern.new do |span|
+          order = yield(span.cycle_number)
+          segment_patterns = Array.new(count) do |index|
+            zoom(Rational(order[index], count), Rational(order[index] + 1, count))
+          end
+
+          Pattern.fastcat(segment_patterns).query_span(span)
+        end
+      end
+    end
+  end
+end

data/lib/cyclotone/transforms/concatenation.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  module Transforms
+    module Concatenation
+      def append(other)
+        Pattern.append(self, other)
+      end
+
+      def fast_append(other)
+        Pattern.fast_append(self, other)
+      end
+    end
+  end
+end

data/lib/cyclotone/transforms/condition.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  module Transforms
+    module Condition
+      def when_mod(period, minimum, &block)
+        Pattern.new do |span|
+          (span.cycle_number % period) >= minimum ? block.call(self).query_span(span) : query_span(span)
+        end
+      end
+
+      def fix(control_pattern, &block)
+        transformed = block.call(self)
+
+        Pattern.new do |span|
+          query_span(span).map do |event|
+            time = event.onset || event.part.start
+            control_value = Pattern.ensure_pattern(control_pattern).query_point(time)
+            next event unless truthy?(control_value)
+
+            transformed_event = transformed.query_event_at(time)
+            transformed_event ? transformed_event.with_span(new_whole: event.whole, new_part: event.part) : event
+          end
+        end
+      end
+
+      def unfix(control_pattern, &block)
+        contrast(block, proc { |pattern| pattern }, control_pattern)
+      end
+
+      def contrast(true_function, false_function, control_pattern)
+        true_pattern = true_function.call(self)
+        false_pattern = false_function.call(self)
+
+        Pattern.new do |span|
+          query_span(span).map do |event|
+            time = event.onset || event.part.start
+            target_pattern = truthy?(Pattern.ensure_pattern(control_pattern).query_point(time)) ? true_pattern : false_pattern
+            target_pattern.query_event_at(time)&.with_span(new_whole: event.whole, new_part: event.part) || event
+          end
+        end
+      end
+
+      def mask(bool_pattern)
+        select_events do |event|
+          truthy?(Pattern.ensure_pattern(bool_pattern).query_point(event.onset || event.part.start))
+        end
+      end
+
+      def struct(bool_pattern)
+        Pattern.ensure_pattern(bool_pattern).combine_left(self) do |gate, value|
+          gate ? value : nil
+        end.select_events { |event| !event.value.nil? }
+      end
+
+      private
+
+      def truthy?(value)
+        !(value.nil? || value == false || value == 0 || value == 0.0 || value == {})
+      end
+    end
+  end
+end

data/lib/cyclotone/transforms/sample.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  module Transforms
+    module Sample
+      def chop(count)
+        Pattern.fastcat(
+          Array.new(count) do |index|
+            merge(Controls.begin(index.to_f / count)).merge(Controls.end((index + 1).to_f / count))
+          end
+        )
+      end
+
+      def striate(count)
+        chop(count)
+      end
+
+      def slice(count, pattern)
+        selection = Pattern.ensure_pattern(pattern)
+
+        map_events do |event|
+          index = selection.query_point(event.onset || event.part.start).to_i % count
+          merge_controls(event, begin: index.to_f / count, end: (index + 1).to_f / count)
+        end
+      end
+
+      def splice(count, pattern)
+        slice(count, pattern).merge(Controls.speed(count))
+      end
+
+      def bite(count, pattern)
+        slice(count, pattern).fast(count)
+      end
+
+      def chew(count, pattern)
+        bite(count, pattern)
+      end
+
+      def randslice(count)
+        map_events do |event|
+          index = Support::Deterministic.int(count, :randslice, event.value, event.part.start)
+          merge_controls(event, begin: index.to_f / count, end: (index + 1).to_f / count)
+        end
+      end
+
+      def loop_at(cycles)
+        merge(Controls.speed(1.0 / cycles.to_f))
+      end
+
+      def segment(count)
+        Pattern.new do |span|
+          cycle_start = Rational(span.cycle_number)
+          segment_length = Rational(1, count)
+
+          Array.new(count) { |index| index }.filter_map do |index|
+            segment_span = TimeSpan.new(
+              cycle_start + (segment_length * index),
+              cycle_start + (segment_length * (index + 1))
+            )
+            overlap = span.intersection(segment_span)
+            next unless overlap
+
+            value = query_point(segment_span.midpoint)
+            Event.new(whole: segment_span, part: overlap, value: value)
+          end
+        end
+      end
+
+      private
+
+      def merge_controls(event, values)
+        merged_value = if event.value.is_a?(Hash)
+                         event.value.merge(values)
+                       else
+                         values.merge(value: event.value)
+                       end
+
+        event.with_value(merged_value)
+      end
+    end
+  end
+end