synth_blocks 1.0.0

data/lib/synth_blocks/mod/adsr.rb

@@ -0,0 +1,83 @@
+module SynthBlocks
+  module Mod
+    ##
+    # Implementation of a linear ADSR envelope generator with a tracking
+    # value so that envelope restarts don't click
+    class Adsr
+      ##
+      # attack time in seconds
+      attr_accessor :attack
+
+      ##
+      # decay time in seconds
+      attr_accessor :decay
+      ##
+      # sustain level (0.0-1.0)
+      attr_accessor :sustain
+
+      ##
+      # release time in seconds
+      attr_accessor :release
+
+      ##
+      # Creates new ADSR envelope
+      #
+      # attack, decay and release are times in seconds (as float)
+      #
+      # sustain should be between 0 and 1
+      def initialize(attack, decay, sustain, release)
+        @value = 0
+        @start_value = 0
+        @attack = attack
+        @decay = decay
+        @sustain = sustain
+        @release = release
+      end
+
+      ##
+      # run the envelope.
+      #
+      # if released is given (should be <= t), the envelope will enter the release stage
+      # returns the current value between 0 and 1
+      def run(t, released)
+        attack_decay = attack + decay
+        if !released
+          if t < 0.0001 # initialize start value (slightly hacky, but works)
+            @start_value = @value
+            return @start_value
+          end
+          if t <= attack # attack
+            return @value = linear(@start_value, 1, attack, t)
+          end
+          if t > attack && t < attack_decay # decay
+            return @value = linear(1.0, sustain, decay, t - attack)
+          end
+          if t >= attack + decay # sustain
+            return @value = sustain
+          end
+        else # release
+          if t <= attack # when released in attack phase
+            attack_level = linear(@start_value, 1, attack, released)
+            return linear(attack_level, 0, release, t - released)
+          end
+          if t > attack && t < attack_decay # when released in decay phase
+            decay_level = linear(1.0, sustain, decay, released - attack)
+            return @value = linear(decay_level, 0, release, t - released)
+          end
+          if t >= attack_decay && t < released + release # normal release
+            return @value = linear(sustain, 0, release, t - released)
+          end
+          if t >= released + release # after release
+            return @value = 0.0
+          end
+        end
+      end
+
+      private
+
+      def linear(start, target, length, time)
+        (target - start) / length * time + start
+      end
+    end
+  end
+end

data/lib/synth_blocks/mod/envelope.rb

@@ -0,0 +1,35 @@
+module SynthBlocks
+  module Mod
+    ##
+    # Simple Attack / Release envelope
+    class Envelope
+      ##
+      # attack time in seconds
+      attr_accessor :attack
+
+      ##
+      # release time in seconds
+      attr_accessor :release
+      ##
+      # create new attack/release envelope
+      def initialize(attack,release)
+        @attack = attack
+        @release = release
+      end
+      ##
+      # run the attack/release envelope
+      # You can override attack and decay
+      def run(t, a=@attack, r=@release)
+        @a = a
+        @r = r
+        if t > @a + @r
+          return 0
+        elsif t > @a #release
+          return 1 - ((1 / @r) * (t - @a))
+        else # attack
+          return 1 / @a * t
+        end
+      end
+    end
+  end
+end

data/lib/synth_blocks/sequencer/sequencer_dsl.rb

@@ -0,0 +1,219 @@
+
+module SynthBlocks
+  module Sequencer
+    ##
+    # A module that implements a sequencer DSL
+    # === Usage
+    #
+    #  include SequencerDSL
+    #  def_pattern(:pattern_name, 16) do
+    #    drum_pattern kickdrum, '*---*---*---*---'
+    #  end
+    #
+    #  my_song = song(bpm: 125) do
+    #    pattern(:pattern_name, at: 0, repeat: 4)
+    #  end
+    #
+    #  output = my_song.render(44100) do |sample|
+    #    kickdrum.run(sample)
+    #  end
+    #  print output.pack('e*')
+    #
+    module SequencerDSL
+
+      P = nil # :nodoc:
+
+      ##
+      # The Pattern class is instantiated by the def_pattern helper
+      class Pattern
+        NOTES=%w(C C# D D# E F F# G G# A A# B) # :nodoc:
+
+        attr_reader :sounds, :steps # :nodoc:
+        def initialize(steps) # :nodoc:
+          @steps = steps
+          @sounds = []
+        end
+
+        def run(block) # :nodoc:
+          instance_eval(&block)
+        end
+
+        ##
+        # Define a drum pattern
+        # - sound is the sound generator object
+        # - pattern is a pattern in the form of a string
+        # === Defining patterns
+        #
+        #   drum_pattern bass_drum, '*---*---*---!---'
+        #
+        # - <tt>*</tt> represents a normal drum hit (velocity: 0.5)
+        # - <tt>!</tt> represents an accented drum hit (velocity 1.0)
+        # - <tt>-</tt> represents a pause (no hit)
+
+        def drum_pattern(sound, pattern)
+          events = []
+          @steps.times do |i|
+            if pattern.chars[i] == '*'
+              events << [i, [:start, 36, 0.5]]
+            elsif pattern.chars[i] == '!'
+              events << [i, [:start, 36, 1.0]]
+            end
+          end
+          @sounds.push([sound, events])
+        end
+
+        def str2note(str) # :nodoc:
+          match = str.upcase.strip.match(/([ABCDEFGH]#?)(-?\d)/)
+          return nil unless match
+          octave = match[2].to_i + 2
+          note = NOTES.index(match[1])
+          if note >= 0 && octave > 0 && octave < 10
+            return 12 * octave + note
+          end
+        end
+
+        ##
+        # Define a note pattern
+        # [sound]   sound generator base class
+        # [pattern] a note pattern
+        #
+        # === Defining a note pattern
+        #
+        #  note_pattern monosynth, [
+        #    ['C4, D#4, G4', 2], P, P, P,
+        #    P, P, P, P,
+        #    P, P, P, P,
+        #    P, P, P, P
+        #  ]
+        #
+        # - <tt>P</tt> is a pause
+        # - a note step in the pattern is an array containing the note and the
+        #   length of the note in steps
+        # - a note is a note name as a string, which consists of the note and the
+        #   octave. To play chords, concatenate notes with commas
+        def note_pattern(sound, pattern)
+          events = []
+          @steps.times do |i|
+            if pattern[i]
+              notes, len = pattern[i]
+              notes.split(',').each do |note|
+                note_num = str2note(note)
+                events << [i, [:start, note_num, 1.0]]
+                events << [i + len, [:stop, note_num]]
+              end
+            end
+          end
+          @sounds.push([sound, events])
+        end
+      end
+
+      ##
+      # Define a note pattern
+      def def_pattern(name, steps, &block)
+        @patterns ||= {}
+        p = Pattern.new(steps)
+        p.run(block)
+        @patterns[name] = p
+      end
+
+      ##
+      # A
+      class Song
+        attr_reader :events, :per_bar, :per_beat # :nodoc:
+        def initialize(bpm, patterns) # :nodoc:
+          @tempo = bpm
+          @events = []
+          @per_beat = 60.0 / @tempo.to_f
+          @per_bar = @per_beat * 4.0
+          @per_step = @per_beat / 4.0
+          @patterns = patterns
+          @latest_time = 0
+        end
+
+        def run(block) # :nodoc:
+          instance_eval(&block)
+        end
+
+        ##
+        # inserts a pattern into the song
+        # [name] pattern needs to be defined by <tt>def_pattern</tt>
+        # [at] Position in bars to insert the pattern to
+        # [repeat] number of times the pattern should repeat
+        # [length] if you want to only use part of the pattern
+        #
+
+        def pattern(name, at: 0, repeat: 1, length: nil)
+          p = @patterns[name]
+          pattern_length = length || p.steps
+          start = at.to_f * @per_bar
+
+          p.sounds.each do |sound, events|
+            repeat.times do |rep|
+
+              events.each do |event|
+                step, data = event
+                next if step > pattern_length
+
+                time = start + (rep.to_f * pattern_length.to_f * @per_step.to_f) + step.to_f * @per_step
+                @latest_time =  time if time > @latest_time
+                type, *rest = data
+                @events << [sound, [type, time, *rest]]
+              end
+            end
+          end
+        end
+
+        ##
+        # Returns the length of the song in seconds plus 2 seconds to allow for
+        # reverb tails etc.
+        def length
+          (@latest_time + 2.0).ceil
+        end
+
+        ##
+        # Sends all scheduled events to the instruments
+        def play
+          @events.each do |event|
+            instrument, data = event
+            instrument.send(*data)
+          end
+        end
+      end
+
+      ##
+      # Define a song in the given tempo (in BPM)
+      # using the Song#pattern method
+
+      def song(bpm: 120, &block)
+        song = Song.new(bpm, @patterns)
+        song.run(block)
+        song.play
+        # File.open("DEBUG.txt", 'wb') do |f|
+        #   f.print song.events.inspect
+        # end
+        song
+      end
+      ##
+      # render the song
+      # the actual rendering needs to be done
+      # manually in the block passed
+      # start & length in bars
+      # block gets an offset in samples it should render
+      def render(sfreq, start=0, len=nil)
+        start_time = start * @per_bar
+        end_time = len ? start_time + len * @per_bar : length
+        start_sample = (sfreq * start_time).floor
+        end_sample = (sfreq * end_time).ceil
+        sample = start_sample
+        sample_len = end_sample - start_sample
+        output = Array.new(sample_len)
+        loop do
+          output[sample - start_sample] = yield sample
+          break if sample > end_sample
+          sample += 1
+        end
+        output
+      end
+    end
+  end
+end

data/lib/synth_blocks/synth/monosynth.rb

@@ -0,0 +1,77 @@
+require 'synth_blocks/core/sound'
+require 'synth_blocks/core/state_variable_filter'
+require 'synth_blocks/core/oscillator'
+require 'synth_blocks/mod/adsr'
+
+module SynthBlocks
+  module Synth
+    ##
+    # A monosynth sound generator
+    class Monosynth < SynthBlocks::Core::Sound
+      ##
+      # === Parameters
+      # - amp_attack, _decay, _sustain, _release - Amp Envelope params
+      # - flt_attack, _decay, _sustain, _release - Filter Envelope params
+      # - flt_envmod - filter envelope modulation amount in Hz
+      # - flt_frequency, flt_Q - filter params
+      # - osc_waveform - waveform to generate (see Oscillator class)
+      def initialize(sfreq, preset={})
+        super(sfreq, mode: :monophonic)
+        @preset = {
+          amp_attack: 0.001,
+          amp_decay: 0.2,
+          amp_sustain: 0.8,
+          amp_release: 0.2,
+          flt_attack: 0.001,
+          flt_decay: 0.05,
+          flt_sustain: 0.0,
+          flt_release: 0.2,
+          flt_envmod: 1000,
+          flt_frequency: 2000,
+          flt_Q: 2,
+          osc_waveform: :square,
+          lfo_waveform: :sine,
+          lfo_frequency: 2
+        }.merge(preset)
+        @oscillator = SynthBlocks::Core::Oscillator.new(@sampling_frequency)
+        @filter = SynthBlocks::Core::StateVariableFilter.new(@sampling_frequency)
+        @filter2 = SynthBlocks::Core::StateVariableFilter.new(@sampling_frequency)
+        @lfo = SynthBlocks::Core::Oscillator.new(@sampling_frequency)
+        @amp_env = SynthBlocks::Mod::Adsr.new(
+          @preset[:amp_attack],
+          @preset[:amp_decay],
+          @preset[:amp_sustain],
+          @preset[:amp_release]
+        )
+        @flt_env = SynthBlocks::Mod::Adsr.new(
+          @preset[:flt_attack],
+          @preset[:flt_decay],
+          @preset[:flt_sustain],
+          @preset[:flt_release]
+        )
+      end
+
+
+      ##
+      # run generator
+      def run(offset)
+        # time in seconds
+        t = time(offset)
+        events = active_events(t)
+        if events.empty?
+          0.0
+        else
+          note = events.keys.last
+          event = events[note]
+          # lfo_out = (@lfo.run(@preset[:lfo_frequency], waveform: @preset[:lfo_waveform]) + 1) / 8 + 0.5
+          osc_out = @oscillator.run(frequency(note), waveform: @preset[:osc_waveform])
+          local_started = t - event[:started]
+          local_stopped = event[:stopped] && event[:stopped] - event[:started]
+          osc_out = @filter.run(osc_out, @preset[:flt_frequency] + @flt_env.run(local_started, local_stopped) * @preset[:flt_envmod], @preset[:flt_Q])
+          # osc_out = @filter2.run(osc_out, @preset[:flt_frequency] + @flt_env.run(local_started, local_stopped) * @preset[:flt_envmod], @preset[:flt_Q])
+          0.3 * osc_out * @amp_env.run(local_started, local_stopped)
+        end
+      end
+    end
+  end
+end

data/lib/synth_blocks/synth/polysynth.rb

@@ -0,0 +1,89 @@
+require 'synth_blocks/core/sound'
+require 'synth_blocks/core/state_variable_filter'
+require 'synth_blocks/core/oscillator'
+require 'synth_blocks/mod/adsr'
+
+module SynthBlocks
+  module Synth
+    class PolyVoice # :nodoc:
+      def initialize(sfreq, parent, preset)
+        @sampling_frequency = sfreq
+        @parent = parent
+        @preset = preset
+        @oscillator = SynthBlocks::Core::Oscillator.new(sfreq)
+        @filter = SynthBlocks::Core::StateVariableFilter.new(sfreq)
+        @amp_env = SynthBlocks::Mod::Adsr.new(@preset[:amp_env_attack], @preset[:amp_env_decay], @preset[:amp_env_sustain], @preset[:amp_env_release])
+        @flt_env = SynthBlocks::Mod::Adsr.new(@preset[:flt_env_attack], @preset[:flt_env_decay], @preset[:flt_env_sustain], @preset[:flt_env_release])
+      end
+
+      def run(started, stopped, frequency, velocity)
+        osc_out = @oscillator.run(frequency, waveform: @preset[:osc_waveform])
+        osc_out = @filter.run(osc_out, @parent.get(:flt_frequency, started) + @flt_env.run(started, stopped) * @parent.get(:flt_envmod, started), @preset[:flt_Q])
+        osc_out = osc_out * @amp_env.run(started, stopped) * velocity
+      end
+
+    end
+
+    ##
+    # A simple polyphonic synthesizer
+    #
+    # OSC > Filter > Amp
+    #
+
+    class Polysynth < SynthBlocks::Core::Sound
+      # === Parameters
+      # - amp_attack, _decay, _sustain, _release - Amp Envelope params
+      # - flt_attack, _decay, _sustain, _release - Filter Envelope params
+      # - flt_envmod - filter envelope modulation amount in Hz
+      # - flt_frequency, flt_Q - filter params
+      # - osc_waveform - waveform to generate (see Oscillator class)
+      def initialize(sfreq, preset = {})
+        @preset = {
+          osc_waveform: :sawtooth,
+          amp_env_attack: 0.2,
+          amp_env_decay: 0.2,
+          amp_env_sustain: 0.8,
+          amp_env_release: 0.5,
+          flt_env_attack: 0.5,
+          flt_env_decay: 0.7,
+          flt_env_sustain: 0.4,
+          flt_env_release: 0.5,
+          flt_frequency: 1000,
+          flt_envmod: 2000,
+          flt_Q: 3
+        }.merge(preset)
+        super(sfreq, mode: :polyphonic)
+        @active_voices = {}
+      end
+
+      def live_params # :nodoc:
+        [:flt_frequency, :flt_envmod]
+      end
+
+      def release(t) # :nodoc:
+        get(:flt_env_release, t)
+      end
+
+      ##
+      # run sound generator
+      def run(offset)
+        t = time(offset)
+        events = active_events(t)
+        voice_results = []
+        events.each do |note, event|
+          local_started = t - event[:started]
+          next if local_started < 0
+          local_stopped = event[:stopped] && event[:stopped] - event[:started]
+          note_key = "#{note}:#{event[:started]}"
+          if @active_voices[note_key].nil?
+            @active_voices[note_key] = PolyVoice.new(@sampling_frequency, self, @preset)
+          end
+          if @active_voices[note_key]
+            voice_results << @active_voices[note_key].run(local_started, local_stopped, frequency(note), event[:velocity])
+          end
+        end
+        0.3 * voice_results.inject(0) {|sum, result| sum + result}
+      end
+    end
+  end
+end