cyclotone 0.1.0

data/lib/cyclotone/oscillators.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  module Oscillators
+    module_function
+
+    def sine
+      Pattern.continuous { |time| (Math.sin(phase(time)) + 1.0) / 2.0 }
+    end
+
+    def cosine
+      Pattern.continuous { |time| (Math.cos(phase(time)) + 1.0) / 2.0 }
+    end
+
+    def tri
+      Pattern.continuous do |time|
+        position = cycle_position(time)
+        position < 0.5 ? position * 2.0 : (1.0 - position) * 2.0
+      end
+    end
+
+    def saw
+      Pattern.continuous { |time| cycle_position(time) }
+    end
+
+    def isaw
+      Pattern.continuous { |time| 1.0 - cycle_position(time) }
+    end
+
+    def square
+      Pattern.continuous { |time| cycle_position(time) < 0.5 ? 0.0 : 1.0 }
+    end
+
+    def rand
+      Pattern.continuous do |time|
+        cycle = time.floor
+        step = ((cycle_position(time) * 128).floor).to_i
+        Support::Deterministic.float(:rand, cycle, step)
+      end
+    end
+
+    def irand(maximum)
+      rand.fmap { |value| (value * maximum.to_i).floor }
+    end
+
+    def perlin
+      Pattern.continuous do |time|
+        left = time.floor
+        right = left + 1
+        amount = cycle_position(time)
+        smooth = amount * amount * (3.0 - (2.0 * amount))
+        left_value = Support::Deterministic.float(:perlin, left)
+        right_value = Support::Deterministic.float(:perlin, right)
+
+        left_value + ((right_value - left_value) * smooth)
+      end
+    end
+
+    def range(low, high, pattern)
+      Pattern.ensure_pattern(pattern).fmap do |value|
+        low.to_f + ((high.to_f - low.to_f) * value.to_f)
+      end
+    end
+
+    def smooth(pattern)
+      source = Pattern.ensure_pattern(pattern)
+      return source if source.continuous?
+
+      Pattern.continuous do |time|
+        interpolate(source, Pattern.to_rational(time))
+      end
+    end
+
+    def cycle_position(time)
+      time.to_f - time.floor
+    end
+    private_class_method :cycle_position
+
+    def phase(time)
+      cycle_position(time) * Math::PI * 2.0
+    end
+    private_class_method :phase
+
+    def interpolate(source, time)
+      anchors = anchors_for(source, time)
+      return source.query_point(time) if anchors.empty?
+
+      left = anchors.reverse.find { |anchor| anchor[:time] <= time } || anchors.first
+      right = anchors.find { |anchor| anchor[:time] >= time } || anchors.last
+      return left[:value] if left[:time] == right[:time]
+
+      amount = (time - left[:time]).to_f / (right[:time] - left[:time]).to_f
+      interpolate_value(left[:value], right[:value], amount)
+    end
+    private_class_method :interpolate
+
+    def anchors_for(source, time)
+      window = TimeSpan.new(time.floor - 1, time.floor + 2)
+
+      source.query_span(window).each_with_object([]) do |event, anchors|
+        next if event.part.duration.zero?
+
+        anchors << { time: event.part.midpoint, value: event.value }
+      end.sort_by { |anchor| anchor[:time] }
+    end
+    private_class_method :anchors_for
+
+    def interpolate_value(left, right, amount)
+      if left.is_a?(Numeric) && right.is_a?(Numeric)
+        left.to_f + ((right.to_f - left.to_f) * amount)
+      elsif left.is_a?(Hash) && right.is_a?(Hash)
+        interpolate_hash(left, right, amount)
+      else
+        amount >= 0.5 ? right : left
+      end
+    end
+    private_class_method :interpolate_value
+
+    def interpolate_hash(left, right, amount)
+      (left.keys | right.keys).each_with_object({}) do |key, result|
+        result[key] =
+          if left.key?(key) && right.key?(key)
+            interpolate_value(left[key], right[key], amount)
+          else
+            amount >= 0.5 ? right.fetch(key, left[key]) : left.fetch(key, right[key])
+          end
+      end
+    end
+    private_class_method :interpolate_hash
+  end
+end

data/lib/cyclotone/pattern.rb

@@ -0,0 +1,361 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  class Pattern
+    include Transforms::Time
+    include Transforms::Concatenation
+    include Transforms::Accumulation
+    include Transforms::Alteration
+    include Transforms::Condition
+    include Transforms::Sample
+
+    SAMPLE_EPSILON = Rational(1, 1024)
+
+    attr_reader :query
+
+    def initialize(continuous: false, &query_func)
+      raise ArgumentError, "Pattern requires a query block" unless query_func
+
+      @continuous = continuous
+      @query = query_func
+      freeze
+    end
+
+    def continuous?
+      @continuous
+    end
+
+    def query_span(span)
+      cycle_spans = span.cycle_spans
+      cycle_spans = [span] if cycle_spans.empty? && continuous?
+
+      cycle_spans.flat_map { |cycle_span| query.call(cycle_span) }.then do |events|
+        self.class.sort_events(events)
+      end
+    end
+
+    def query_cycle(cycle_number)
+      query_span(TimeSpan.new(cycle_number, Rational(cycle_number) + 1))
+    end
+
+    def query_event_at(time)
+      query_span(TimeSpan.new(time, time + SAMPLE_EPSILON)).find { |event| event.covers_time?(time) }
+    end
+
+    def query_point(time)
+      query_event_at(time)&.value
+    end
+
+    def fmap(&transform)
+      raise ArgumentError, "fmap requires a block" unless transform
+
+      Pattern.new(continuous: continuous?) do |span|
+        query_span(span).map { |event| event.with_value(transform.call(event.value)) }
+      end
+    end
+
+    def map_events(&transform)
+      Pattern.new(continuous: continuous?) do |span|
+        query_span(span).map { |event| transform.call(event) }.compact
+      end
+    end
+
+    def flat_map_events(&transform)
+      Pattern.new(continuous: continuous?) do |span|
+        query_span(span).flat_map { |event| Array(transform.call(event)) }.compact
+      end
+    end
+
+    def select_events(&predicate)
+      Pattern.new(continuous: continuous?) do |span|
+        query_span(span).select { |event| predicate.call(event) }
+      end
+    end
+
+    def combine_left(other, &operation)
+      other_pattern = self.class.ensure_pattern(other)
+
+      Pattern.new(continuous: continuous?) do |span|
+        query_span(span).map do |event|
+          time = event.onset || event.part.start
+          other_value = other_pattern.query_point(time)
+          event.with_value(operation.call(event.value, other_value))
+        end
+      end
+    end
+
+    def combine_right(other, &operation)
+      self.class.ensure_pattern(other).combine_left(self) do |right_value, left_value|
+        operation.call(left_value, right_value)
+      end
+    end
+
+    def combine_both(other, &operation)
+      other_pattern = self.class.ensure_pattern(other)
+
+      Pattern.new do |span|
+        left_events = query_span(span)
+        right_events = other_pattern.query_span(span)
+
+        left_events.flat_map do |left_event|
+          right_events.filter_map do |right_event|
+            overlap = left_event.active_span.intersection(right_event.active_span)
+            next unless overlap
+
+            part = overlap.intersection(span)
+            next unless part
+
+            whole = left_event.whole && right_event.whole ? left_event.whole.intersection(right_event.whole) : nil
+
+            Event.new(
+              whole: whole,
+              part: part,
+              value: operation.call(left_event.value, right_event.value)
+            )
+          end
+        end
+      end
+    end
+
+    def add(other, structure: :both)
+      apply_binary_operation(other, structure: structure) { |left, right| combine_scalar(left, right, :+) }
+    end
+
+    def sub(other, structure: :both)
+      apply_binary_operation(other, structure: structure) { |left, right| combine_scalar(left, right, :-) }
+    end
+
+    def mul(other, structure: :both)
+      apply_binary_operation(other, structure: structure) { |left, right| combine_scalar(left, right, :*) }
+    end
+
+    def div(other, structure: :both)
+      apply_binary_operation(other, structure: structure) { |left, right| combine_scalar(left, right, :/) }
+    end
+
+    def mod(other, structure: :both)
+      apply_binary_operation(other, structure: structure) { |left, right| combine_scalar(left, right, :%) }
+    end
+
+    def merge(other)
+      combine_left(other) do |left, right|
+        if left.is_a?(Hash) && right.is_a?(Hash)
+          left.merge(right)
+        elsif right.nil?
+          left
+        else
+          right
+        end
+      end
+    end
+
+    def +(other)
+      add(other)
+    end
+
+    def -(other)
+      sub(other)
+    end
+
+    def *(other)
+      mul(other)
+    end
+
+    def /(other)
+      div(other)
+    end
+
+    def %(other)
+      mod(other)
+    end
+
+    class << self
+      def pure(value)
+        Pattern.new do |span|
+          cycle_start = Rational(span.cycle_number)
+          whole = TimeSpan.new(cycle_start, cycle_start + 1)
+          [Event.new(whole: whole, part: span, value: value)]
+        end
+      end
+
+      alias atom pure
+
+      def silence
+        Pattern.new { |_span| [] }
+      end
+
+      def continuous(&sampler)
+        Pattern.new(continuous: true) do |span|
+          [Event.new(whole: nil, part: span, value: sampler.call(span.midpoint))]
+        end
+      end
+
+      def ensure_pattern(value)
+        value.is_a?(Pattern) ? value : pure(value)
+      end
+
+      def to_rational(value)
+        return value if value.is_a?(Rational)
+        return Rational(value, 1) if value.is_a?(Integer)
+
+        Rational(value.to_s)
+      end
+
+      def timecat(weighted_patterns)
+        normalized = Array(weighted_patterns)
+        raise ArgumentError, "timecat requires patterns" if normalized.empty?
+
+        total_weight = normalized.sum { |weight, _pattern| to_rational(weight) }
+
+        Pattern.new do |span|
+          cycle_start = Rational(span.cycle_number)
+          cursor = cycle_start
+
+          normalized.flat_map do |weight, pattern|
+            normalized_weight = to_rational(weight)
+            segment_length = normalized_weight / total_weight
+            segment_span = TimeSpan.new(cursor, cursor + segment_length)
+            overlap = span.intersection(segment_span)
+            cursor += segment_length
+
+            next [] unless overlap
+
+            local_span = TimeSpan.new(
+              (overlap.start - segment_span.start) / segment_length,
+              (overlap.stop - segment_span.start) / segment_length
+            )
+
+            ensure_pattern(pattern).query_span(local_span).map do |event|
+              map_event(event) do |time|
+                segment_span.start + (time * segment_length)
+              end
+            end
+          end
+        end
+      end
+
+      def fastcat(patterns)
+        timecat(Array(patterns).map { |pattern| [1, pattern] })
+      end
+
+      def cat(patterns)
+        normalized = Array(patterns)
+        raise ArgumentError, "cat requires patterns" if normalized.empty?
+
+        Pattern.new do |span|
+          cycle = span.cycle_number
+          index = cycle % normalized.length
+          local_cycle = cycle / normalized.length
+          cycle_offset = cycle - local_cycle
+          local_span = span.shift(-cycle_offset)
+
+          ensure_pattern(normalized[index]).query_span(local_span).map do |event|
+            shift_event(event, cycle_offset)
+          end
+        end
+      end
+
+      def randcat(patterns)
+        normalized = Array(patterns)
+
+        Pattern.new do |span|
+          index = Support::Deterministic.int(normalized.length, :randcat, span.cycle_number)
+          ensure_pattern(normalized[index]).query_span(span)
+        end
+      end
+
+      def append(first, second)
+        cat([first, second])
+      end
+
+      def fast_append(first, second)
+        fastcat([first, second])
+      end
+
+      def stack(patterns)
+        normalized_patterns = Array(patterns).map { |pattern| ensure_pattern(pattern) }
+        raise ArgumentError, "stack requires at least one pattern" if normalized_patterns.empty?
+
+        Pattern.new do |span|
+          normalized_patterns.flat_map { |pattern| pattern.query_span(span) }.then do |events|
+            sort_events(events)
+          end
+        end
+      end
+
+      def overlay(first, second)
+        stack([first, second])
+      end
+
+      def mn(string)
+        compiler.compile(parser.parse(string))
+      end
+
+      def parser
+        @parser ||= MiniNotation::Parser.new
+      end
+
+      def compiler
+        @compiler ||= MiniNotation::Compiler.new
+      end
+
+      def sort_events(events)
+        events.sort_by do |event|
+          [event.onset || event.part.start, event.offset || event.part.stop, event.value.to_s]
+        end
+      end
+
+      def map_span(span, &block)
+        return nil unless span
+
+        TimeSpan.new(block.call(span.start), block.call(span.stop))
+      end
+
+      def map_event(event, &block)
+        Event.new(
+          whole: map_span(event.whole, &block),
+          part: map_span(event.part, &block),
+          value: event.value
+        )
+      end
+
+      def shift_event(event, amount)
+        offset = to_rational(amount)
+        map_event(event) { |time| time + offset }
+      end
+    end
+
+    private
+
+    def apply_binary_operation(other, structure:, &operation)
+      case structure
+      when :left
+        combine_left(other, &operation)
+      when :right
+        combine_right(other, &operation)
+      else
+        combine_both(other, &operation)
+      end
+    end
+
+    def combine_scalar(left, right, operator)
+      if left.is_a?(Hash) && right.is_a?(Hash)
+        keys = left.keys | right.keys
+        keys.each_with_object({}) do |key, result|
+          result[key] =
+            if left.key?(key) && right.key?(key) && left[key].respond_to?(operator)
+              left[key].public_send(operator, right[key])
+            else
+              right.fetch(key, left[key])
+            end
+        end
+      elsif right.nil?
+        left
+      elsif left.respond_to?(operator)
+        left.public_send(operator, right)
+      else
+        left
+      end
+    end
+  end
+end

data/lib/cyclotone/scheduler.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require "thread"
+
+module Cyclotone
+  class Scheduler
+    LOOKAHEAD = 0.3
+    INTERVAL = 0.05
+    DEFAULT_CPS = Rational(9, 16)
+
+    attr_reader :backend, :cps, :lookahead, :interval
+
+    def initialize(cps: DEFAULT_CPS, backend:, lookahead: LOOKAHEAD, interval: INTERVAL, logger: nil)
+      @backend = backend
+      @cps = cps.to_f
+      @lookahead = lookahead
+      @interval = interval
+      @logger = logger
+      @mutex = Mutex.new
+      @patterns = {}
+      @sent = {}
+      @running = false
+      @start_monotonic = monotonic_time
+      @start_wall_time = Time.now.to_f
+      @start_cycle = 0.0
+      @last_cycle = 0.0
+    end
+
+    def start
+      return if @running
+
+      @running = true
+      @thread = Thread.new do
+        while @running
+          begin
+            tick
+          rescue StandardError => error
+            log_runtime_error(error)
+          end
+
+          sleep(@interval)
+        end
+      end
+    end
+
+    def stop
+      @running = false
+      @thread&.join
+    end
+
+    def tick(now = monotonic_time)
+      state = snapshot_state
+      logical_end = time_to_cycle(now + lookahead, state[:cps], state[:start_cycle], state[:start_monotonic])
+      dispatch_until(logical_end, state)
+    end
+
+    def update_pattern(slot_id, pattern)
+      @mutex.synchronize { @patterns[slot_id] = Pattern.ensure_pattern(pattern) }
+    end
+
+    def remove_pattern(slot_id)
+      @mutex.synchronize { @patterns.delete(slot_id) }
+    end
+
+    def setcps(value)
+      now = monotonic_time
+      wall_now = Time.now.to_f
+
+      @mutex.synchronize do
+        current_cycle = time_to_cycle(now, @cps, @start_cycle, @start_monotonic)
+
+        @start_cycle = current_cycle
+        @start_monotonic = now
+        @start_wall_time = wall_now
+        @cps = value.to_f
+      end
+    end
+
+    def reset_cycles
+      set_cycle(0)
+    end
+
+    def set_cycle(value)
+      @mutex.synchronize do
+        @start_cycle = value.to_f
+        @start_monotonic = monotonic_time
+        @start_wall_time = Time.now.to_f
+        @last_cycle = value.to_f
+        @sent.clear
+      end
+    end
+
+    def backend=(backend)
+      @mutex.synchronize { @backend = backend }
+    end
+
+    def current_cycle(now = monotonic_time)
+      @mutex.synchronize { time_to_cycle(now, @cps, @start_cycle, @start_monotonic) }
+    end
+
+    def running?
+      @running
+    end
+
+    def render(duration:)
+      duration_value = duration.to_f
+      raise ArgumentError, "render duration must be non-negative" if duration_value.negative?
+
+      state = snapshot_state
+      state[:backend].begin_capture(at: state[:start_wall_time]) if state[:backend].respond_to?(:begin_capture)
+
+      logical_end = state[:start_cycle] + (duration_value * state[:cps])
+      dispatch_until(logical_end, state)
+      self
+    end
+
+    private
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def snapshot_state
+      @mutex.synchronize do
+        {
+          patterns: @patterns.dup,
+          cps: @cps,
+          last_cycle: @last_cycle,
+          start_cycle: @start_cycle,
+          start_monotonic: @start_monotonic,
+          start_wall_time: @start_wall_time,
+          backend: @backend
+        }
+      end
+    end
+
+    def dispatch_until(logical_end, state)
+      return if logical_end <= state[:last_cycle]
+
+      query_span = TimeSpan.new(Rational(state[:last_cycle].to_r), Rational(logical_end.to_r))
+
+      state[:patterns].each do |slot_id, pattern|
+        pattern.query_span(query_span).each do |event|
+          next unless event.onset
+
+          key = [slot_id, event.onset, event.value]
+          next if @sent[key]
+
+          absolute_time = state[:start_wall_time] + ((event.onset.to_f - state[:start_cycle]) / state[:cps])
+          state[:backend].send_event(event, at: absolute_time, cps: state[:cps])
+          @sent[key] = true
+        rescue StandardError => error
+          log_runtime_error(error)
+        end
+      end
+
+      @mutex.synchronize { @last_cycle = logical_end }
+    end
+
+    def time_to_cycle(time, cps_value, start_cycle, start_monotonic)
+      start_cycle + ((time - start_monotonic) * cps_value)
+    end
+
+    def log_runtime_error(error)
+      @logger&.call("[Cyclotone::Scheduler] #{error.class}: #{error.message}")
+    end
+  end
+end

data/lib/cyclotone/state.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "thread"
+
+module Cyclotone
+  class State
+    include Singleton
+
+    def initialize
+      @values = {}
+      @mutex = Mutex.new
+    end
+
+    def set_f(key, value)
+      write(key, value.to_f)
+    end
+
+    def set_i(key, value)
+      write(key, value.to_i)
+    end
+
+    def set_s(key, value)
+      write(key, value.to_s)
+    end
+
+    def get_f(key)
+      read(key)&.to_f
+    end
+
+    def get_i(key)
+      read(key)&.to_i
+    end
+
+    def get_s(key)
+      read(key)&.to_s
+    end
+
+    private
+
+    def write(key, value)
+      @mutex.synchronize { @values[key.to_sym] = value }
+    end
+
+    def read(key)
+      @mutex.synchronize { @values[key.to_sym] }
+    end
+  end
+end