cyclotone 0.1.0

data/lib/cyclotone/controls.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  module Controls
+    CONTROL_DEFS = {
+      s: { type: :string, aliases: [:sound] },
+      n: { type: :integer },
+      speed: { type: :float, default: 1.0 },
+      begin: { type: :float, aliases: [:sample_begin] },
+      end: { type: :float, aliases: [:sample_end] },
+      pan: { type: :float, default: 0.5 },
+      gain: { type: :float, default: 1.0 },
+      amp: { type: :float, default: 1.0 },
+      cut: { type: :integer },
+      unit: { type: :string },
+      accelerate: { type: :float },
+      legato: { type: :float },
+      attack: { type: :float, aliases: [:att] },
+      hold: { type: :float },
+      release: { type: :float, aliases: [:rel] },
+      cutoff: { type: :float, aliases: [:lpf] },
+      resonance: { type: :float, aliases: [:lpq] },
+      hcutoff: { type: :float, aliases: [:hpf] },
+      hresonance: { type: :float, aliases: [:hpq] },
+      bandf: { type: :float, aliases: [:bpf] },
+      bandq: { type: :float, aliases: [:bpq] },
+      djf: { type: :float },
+      vowel: { type: :string },
+      delay: { type: :float },
+      delaytime: { type: :float, aliases: [:delayt] },
+      delayfeedback: { type: :float, aliases: [:delayfb] },
+      lock: { type: :integer },
+      dry: { type: :float },
+      room: { type: :float },
+      size: { type: :float, aliases: [:sz] },
+      distort: { type: :float },
+      triode: { type: :float },
+      shape: { type: :float },
+      squiz: { type: :float },
+      crush: { type: :float },
+      coarse: { type: :float },
+      tremolorate: { type: :float, aliases: [:tremr] },
+      tremolodepth: { type: :float, aliases: [:tremdp] },
+      phaserrate: { type: :float, aliases: [:phasr] },
+      phaserdepth: { type: :float, aliases: [:phasdp] },
+      leslie: { type: :float },
+      lrate: { type: :float },
+      lsize: { type: :float },
+      octer: { type: :float },
+      octersub: { type: :float },
+      octersubsub: { type: :float },
+      fshift: { type: :float },
+      fshiftnote: { type: :float },
+      fshiftphase: { type: :float },
+      ring: { type: :float },
+      ringf: { type: :float },
+      ringdf: { type: :float },
+      note: { type: :integer },
+      velocity: { type: :integer, default: 100 },
+      sustain: { type: :float, default: 1.0 },
+      channel: { type: :integer, default: 0 },
+      cc: { type: :hash }
+    }.freeze
+
+    ALIASES = CONTROL_DEFS.each_with_object({}) do |(name, options), mapping|
+      mapping[name] = name
+      Array(options[:aliases]).each { |alias_name| mapping[alias_name] = name }
+    end.freeze
+
+    module_function
+
+    CONTROL_DEFS.each_key do |name|
+      define_method(name) do |pattern_or_value|
+        factory(name, pattern_or_value)
+      end
+
+      Array(CONTROL_DEFS[name][:aliases]).each do |alias_name|
+        define_method(alias_name) do |pattern_or_value|
+          factory(name, pattern_or_value)
+        end
+      end
+    end
+
+    def control(name, pattern_or_value)
+      factory(name, pattern_or_value)
+    end
+
+    def factory(name, pattern_or_value)
+      canonical_name = canonical(name)
+      pattern = coerce_pattern(pattern_or_value)
+
+      pattern.fmap do |value|
+        wrap_value(canonical_name, value)
+      end
+    end
+
+    def coerce_pattern(pattern_or_value)
+      return pattern_or_value if pattern_or_value.is_a?(Pattern)
+      return Pattern.mn(pattern_or_value) if pattern_or_value.is_a?(String)
+
+      Pattern.pure(pattern_or_value)
+    end
+
+    def wrap_value(control_name, value)
+      if value.is_a?(Hash)
+        if control_name == :s && (value.key?(:s) || value.key?(:n))
+          value.merge(s: value[:s] || value[:value])
+        elsif control_name == :note && value.key?(:note)
+          value
+        else
+          value.merge(control_name => value[control_name] || value[:value] || value)
+        end
+      else
+        { control_name => value }
+      end
+    end
+
+    def canonical(name)
+      ALIASES.fetch(name.to_sym) { raise InvalidControlError, "unknown control #{name}" }
+    end
+  end
+end
+
+module Cyclotone
+  class Pattern
+    Controls::CONTROL_DEFS.each_key do |name|
+      define_method(name) do |pattern_or_value|
+        merge(Controls.factory(name, pattern_or_value))
+      end
+
+      Array(Controls::CONTROL_DEFS[name][:aliases]).each do |alias_name|
+        define_method(alias_name) do |pattern_or_value|
+          merge(Controls.factory(name, pattern_or_value))
+        end
+      end
+    end
+
+    def control(name, pattern_or_value)
+      merge(Controls.factory(name, pattern_or_value))
+    end
+  end
+end

data/lib/cyclotone/dsl.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  module DSL
+    Controls::ALIASES.each_key do |name|
+      define_method(name) do |pattern_or_value = nil|
+        Controls.public_send(name, pattern_or_value)
+      end
+    end
+
+    %i[sine cosine tri saw isaw square rand irand perlin range smooth].each do |name|
+      define_method(name) do |*args|
+        Oscillators.public_send(name, *args)
+      end
+    end
+
+    def stream
+      Stream.instance
+    end
+
+    (1..16).each do |index|
+      define_method(:"d#{index}") do |pattern = nil, &block|
+        target_pattern = block ? block.call : pattern
+        stream.d(index, target_pattern)
+      end
+    end
+
+    def p(name, pattern = nil, &block)
+      target_pattern = block ? block.call : pattern
+      stream.p(name, target_pattern)
+    end
+
+    def hush
+      stream.hush
+    end
+
+    def setcps(value)
+      stream.setcps(value)
+    end
+
+    def reset_cycles
+      stream.reset_cycles
+    end
+
+    def set_cycle(value)
+      stream.set_cycle(value)
+    end
+
+    def trigger
+      stream.trigger
+    end
+
+    def qtrigger
+      stream.qtrigger
+    end
+
+    def mtrigger(period)
+      stream.mtrigger(period)
+    end
+
+    def xfade(id, pattern)
+      stream.xfade(id, pattern)
+    end
+
+    def xfade_in(id, cycles, pattern)
+      stream.xfade_in(id, cycles, pattern)
+    end
+
+    def clutch(id, pattern)
+      stream.clutch(id, pattern)
+    end
+
+    def clutch_in(id, cycles, pattern)
+      stream.clutch_in(id, cycles, pattern)
+    end
+
+    def interpolate(id, pattern)
+      stream.interpolate(id, pattern)
+    end
+
+    def interpolate_in(id, cycles, pattern)
+      stream.interpolate_in(id, cycles, pattern)
+    end
+
+    def jump(id, pattern)
+      stream.jump(id, pattern)
+    end
+
+    def jump_in(id, cycles, pattern)
+      stream.jump_in(id, cycles, pattern)
+    end
+
+    def anticipate(id, pattern)
+      stream.anticipate(id, pattern)
+    end
+
+    def solo(id)
+      stream.solo(id)
+    end
+
+    def unsolo(id)
+      stream.unsolo(id)
+    end
+
+    def mute(id)
+      stream.mute(id)
+    end
+
+    def unmute(id)
+      stream.unmute(id)
+    end
+
+    def fade_in(cycles)
+      stream.fade_in(cycles)
+    end
+
+    def fade_out(cycles)
+      stream.fade_out(cycles)
+    end
+
+    def start
+      stream.start
+    end
+
+    def stop
+      stream.stop
+    end
+
+    def chord(name, root: 0)
+      Harmony.chord(name, root: root)
+    end
+
+    def scale(name, pattern, root: 0)
+      Harmony.scale(name, pattern, root: root)
+    end
+
+    def running?
+      stream.running?
+    end
+  end
+end

data/lib/cyclotone/errors.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  class Error < StandardError; end
+
+  class ParseError < Error
+    attr_reader :line, :column
+
+    def initialize(message, line: nil, column: nil)
+      @line = line
+      @column = column
+
+      super(format_message(message))
+    end
+
+    private
+
+    def format_message(message)
+      return message unless line && column
+
+      "#{message} at line #{line}, column #{column}"
+    end
+  end
+
+  class ConnectionError < Error; end
+  class InvalidControlError < Error; end
+end

data/lib/cyclotone/euclidean.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  module Euclidean
+    module_function
+
+    def generate(pulses, steps, rotation = 0)
+      normalized_pulses = pulses.to_i
+      normalized_steps = steps.to_i
+
+      raise ArgumentError, "steps must be positive" if normalized_steps <= 0
+      raise ArgumentError, "pulses must be between 0 and steps" if normalized_pulses.negative? || normalized_pulses > normalized_steps
+
+      pattern = bjorklund(normalized_pulses, normalized_steps)
+      pattern = pattern.rotate(pattern.index(true) || 0)
+      rotate(pattern, rotation)
+    end
+
+    def bjorklund(pulses, steps)
+      return Array.new(steps, false) if pulses.zero?
+      return Array.new(steps, true) if pulses == steps
+
+      counts = []
+      remainders = [pulses]
+      divisor = steps - pulses
+      level = 0
+
+      while remainders[level] > 1
+        counts << (divisor / remainders[level])
+        remainders << (divisor % remainders[level])
+        divisor = remainders[level]
+        level += 1
+      end
+
+      counts << divisor
+
+      pattern = []
+      build(level, counts, remainders, pattern)
+      pattern.take(steps)
+    end
+    private_class_method :bjorklund
+
+    def build(level, counts, remainders, pattern)
+      case level
+      when -1
+        pattern << false
+      when -2
+        pattern << true
+      else
+        counts[level].times { build(level - 1, counts, remainders, pattern) }
+        build(level - 2, counts, remainders, pattern) unless remainders[level].zero?
+      end
+    end
+    private_class_method :build
+
+    def rotate(pattern, rotation)
+      return pattern if pattern.empty?
+
+      normalized_rotation = rotation.to_i % pattern.length
+
+      pattern.rotate(normalized_rotation)
+    end
+    private_class_method :rotate
+  end
+end

data/lib/cyclotone/event.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  class Event
+    attr_reader :whole, :part, :value
+
+    def initialize(whole:, part:, value:)
+      @whole = whole
+      @part = part
+      @value = value
+      freeze
+    end
+
+    def onset
+      whole&.start
+    end
+
+    def offset
+      whole&.stop
+    end
+
+    def triggered?
+      return false unless onset
+
+      part.includes?(onset)
+    end
+
+    def duration
+      whole&.duration
+    end
+
+    def has_whole?
+      !whole.nil?
+    end
+
+    def active_span
+      whole || part
+    end
+
+    def covers_time?(time)
+      active_span.includes?(time)
+    end
+
+    def with_value(new_value)
+      self.class.new(whole: whole, part: part, value: new_value)
+    end
+
+    def with_span(new_whole: whole, new_part: part)
+      self.class.new(whole: new_whole, part: new_part, value: value)
+    end
+
+    def ==(other)
+      other.is_a?(self.class) &&
+        whole == other.whole &&
+        part == other.part &&
+        value == other.value
+    end
+
+    alias eql? ==
+
+    def hash
+      [self.class, whole, part, value].hash
+    end
+  end
+end

data/lib/cyclotone/harmony.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Cyclotone
+  module Harmony
+    NOTE_OFFSETS = {
+      "c" => 0, "cs" => 1, "db" => 1, "d" => 2, "ds" => 3, "eb" => 3, "e" => 4,
+      "f" => 5, "fs" => 6, "gb" => 6, "g" => 7, "gs" => 8, "ab" => 8, "a" => 9,
+      "as" => 10, "bb" => 10, "b" => 11
+    }.freeze
+
+    SCALES = {
+      major: [0, 2, 4, 5, 7, 9, 11],
+      minor: [0, 2, 3, 5, 7, 8, 10],
+      dorian: [0, 2, 3, 5, 7, 9, 10],
+      phrygian: [0, 1, 3, 5, 7, 8, 10],
+      lydian: [0, 2, 4, 6, 7, 9, 11],
+      mixolydian: [0, 2, 4, 5, 7, 9, 10],
+      locrian: [0, 1, 3, 5, 6, 8, 10],
+      harmonic_minor: [0, 2, 3, 5, 7, 8, 11],
+      melodic_minor: [0, 2, 3, 5, 7, 9, 11],
+      whole_tone: [0, 2, 4, 6, 8, 10],
+      chromatic: (0..11).to_a,
+      pentatonic_major: [0, 2, 4, 7, 9],
+      pentatonic_minor: [0, 3, 5, 7, 10],
+      blues: [0, 3, 5, 6, 7, 10],
+      egyptian: [0, 2, 5, 7, 10],
+      hirajoshi: [0, 2, 3, 7, 8],
+      iwato: [0, 1, 5, 6, 10],
+      enigmatic: [0, 1, 4, 6, 8, 10, 11],
+      neapolitan_major: [0, 1, 3, 5, 7, 9, 11],
+      neapolitan_minor: [0, 1, 3, 5, 7, 8, 11]
+    }.freeze
+
+    CHORDS = {
+      major: [0, 4, 7],
+      minor: [0, 3, 7],
+      diminished: [0, 3, 6],
+      augmented: [0, 4, 8],
+      sus2: [0, 2, 7],
+      sus4: [0, 5, 7],
+      major7: [0, 4, 7, 11],
+      minor7: [0, 3, 7, 10],
+      dominant7: [0, 4, 7, 10]
+    }.freeze
+
+    module_function
+
+    def scale(name, pattern, root: 0)
+      intervals = SCALES.fetch(name.to_sym)
+      root_note = note_number(root)
+
+      Pattern.ensure_pattern(pattern).fmap do |value|
+        apply_scale(intervals, root_note, value)
+      end
+    end
+
+    def chord(name, root: 0)
+      root_note = note_number(root)
+      notes = CHORDS.fetch(name.to_sym) { raise ArgumentError, "unknown chord #{name}" }.map do |interval|
+        root_note + interval
+      end
+
+      Pattern.pure(notes)
+    end
+
+    def arpeggiate(pattern, mode: :up)
+      Pattern.ensure_pattern(pattern).flat_map_events do |event|
+        notes = extract_notes(event.value)
+        next [event] if notes.empty?
+
+        ordered = order_notes(notes, mode)
+        segment_length = event.part.duration / ordered.length
+
+        ordered.each_with_index.map do |note, index|
+          part = TimeSpan.new(
+            event.part.start + (segment_length * index),
+            event.part.start + (segment_length * (index + 1))
+          )
+
+          Event.new(whole: part, part: part, value: note)
+        end
+      end
+    end
+
+    def note_number(value)
+      return value.to_i if value.is_a?(Numeric)
+
+      normalized = value.to_s.strip.downcase
+      match = normalized.match(/\A([a-g](?:s|b)?)(-?\d+)\z/)
+      return normalized.to_i if match.nil?
+
+      NOTE_OFFSETS.fetch(match[1]) + ((match[2].to_i + 1) * 12)
+    end
+
+    def apply_scale(intervals, root_note, value)
+      if value.is_a?(Hash) && value.key?(:note)
+        value.merge(note: map_degree(intervals, root_note, value[:note]))
+      else
+        map_degree(intervals, root_note, value)
+      end
+    end
+    private_class_method :apply_scale
+
+    def map_degree(intervals, root_note, value)
+      degree = note_number(value)
+      octave, index = degree.divmod(intervals.length)
+      root_note + intervals[index] + (octave * 12)
+    end
+    private_class_method :map_degree
+
+    def extract_notes(value)
+      return value[:note] if value.is_a?(Hash) && value[:note].is_a?(Array)
+      return value if value.is_a?(Array)
+
+      []
+    end
+    private_class_method :extract_notes
+
+    def order_notes(notes, mode)
+      case mode.to_sym
+      when :down
+        notes.reverse
+      when :updown
+        notes + notes[1...-1].reverse
+      when :converge
+        left = notes.each_slice(2).map(&:first)
+        right = notes.each_slice(2).map(&:last).compact.reverse
+        left.zip(right).flatten.compact
+      else
+        notes
+      end
+    end
+    private_class_method :order_notes
+  end
+end
+
+module Cyclotone
+  class Pattern
+    def up(semitones)
+      fmap do |value|
+        if value.is_a?(Hash) && value.key?(:note)
+          value.merge(note: value[:note] + semitones.to_i)
+        else
+          value + semitones.to_i
+        end
+      end
+    end
+
+    def scale(name, root: 0)
+      Harmony.scale(name, self, root: root)
+    end
+
+    def arp(mode = :up)
+      Harmony.arpeggiate(self, mode: mode)
+    end
+
+    alias arpeggiate arp
+  end
+end