synth_blocks 1.0.0

data/README.md

@@ -0,0 +1,40 @@
+# Synth Blocks
+
+Synth blocks is a proper extraction of the synthesizer/sequncer I built for my [Ruby Synth](https://rubysynth.fun) talk an Euruko and RubyConf.by
+
+It is a gem and can be used for writing electronic music in ruby. See [examples](examples/) for more info on how to use this.
+
+## Blocks
+
+The code is divided into 7 sections:
+
+- Core contains things like Oscillators and filters, a base class for all generators as well as a class that uses the wavefile gem to write out sound files
+- Mod contains modulators, currently two Envelopes
+- Drum and Synth contains Drum and Synthesizer generators respectively
+- Fx contains Audio effects such as Reverb, Chorus, Delay, Waveshaper and more
+- Mixer contains utilities to build a mixing system
+- Sequencer contains a DSL for building songs
+
+The code is super unoptimised, as it is written for learning purposes. This means, for example, that the full song contained in [examples/a_song.rb](examples/a_song.rb) 
+takes a couple of hours to render. I'm relatively sure that there are some low hanging fruits for optimisation, especially in the sequencer code that does a lot of
+useless lookups on quite large data structures that hold the automation data, but I haven't yet gotten around to take a look at it.
+
+## Examples
+
+The easiest way to test the example code is to check out the repo and then execute the code directly.
+
+Each example has a line on the bottom:
+
+```ruby
+SynthBlocks::Core::WaveWriter.write_if_name_given(out)
+```
+
+This will write out a wave file if you run the file with a wav-file as the last argument like so:
+
+```bash
+ruby -Ilib examples/waveshaper_demo.rb test.wav
+```
+
+## License
+
+All code here is licensed under the AGPL 3.0 license as documented at [LICENSE](LICENSE) unless stated otherwise.

data/lib/synth_blocks.rb

@@ -0,0 +1,24 @@
+require 'synth_blocks/core/sound'
+require 'synth_blocks/mod/adsr'
+require 'synth_blocks/fx/chorus'
+require 'synth_blocks/fx/compressor'
+require 'synth_blocks/fx/delay'
+require 'synth_blocks/mod/envelope'
+require 'synth_blocks/fx/eq'
+require 'synth_blocks/fx/g_verb'
+require 'synth_blocks/drum/hihat'
+require 'synth_blocks/drum/kick_drum'
+require 'synth_blocks/drum/tuned_drum'
+require 'synth_blocks/mixer/mixer_channel'
+require 'synth_blocks/synth/monosynth'
+require 'synth_blocks/core/moog_filter'
+require 'synth_blocks/core/oscillator'
+require 'synth_blocks/synth/polysynth'
+require 'synth_blocks/mixer/send_channel'
+require 'synth_blocks/sequencer/sequencer_dsl'
+require 'synth_blocks/drum/snare_drum'
+require 'synth_blocks/core/state_variable_filter'
+require 'synth_blocks/utils'
+require 'synth_blocks/fx/waveshaper'
+require 'synth_blocks/fx/limiter'
+require 'synth_blocks/core/wave_writer'

data/lib/synth_blocks/core/moog_filter.rb

@@ -0,0 +1,35 @@
+# A better sounding lowpass (for some applications that is)
+# Source http://www.musicdsp.org/en/latest/Filters/26-moog-vcf-variation-2.html
+# Straight port from c++
+module SynthBlocks
+  module Core
+    class MoogFilter
+      ##
+      # create new instance
+      def initialize
+        @in1 = @in2 = @in3 = @in4 = 0
+        @out1 = @out2 = @out3 = @out4 = 0
+      end
+
+      ##
+      # runs the filter on the input value
+      # fc is the cutoff frequency (not in Hz but from 0..1)
+      # res is the resonance from 0..4
+      def run(input, fc, res)
+        f = fc * 1.16;
+        fb = res * (1.0 - 0.15 * f * f);
+        input -= @out4 * fb;
+        input *= 0.35013 * (f*f)*(f*f);
+        @out1 = input + 0.3 * @in1 + (1 - f) * @out1; # Pole 1
+        @in1  = input;
+        @out2 = @out1 + 0.3 * @in2 + (1 - f) * @out2;  # Pole 2
+        @in2  = @out1;
+        @out3 = @out2 + 0.3 * @in3 + (1 - f) * @out3;  # Pole 3
+        @in3  = @out2;
+        @out4 = @out3 + 0.3 * @in4 + (1 - f) * @out4;  # Pole 4
+        @in4  = @out3;
+        return @out4;
+      end
+    end
+  end
+end

data/lib/synth_blocks/core/one_pole_lowpass.rb

@@ -0,0 +1,14 @@
+module SynthBlocks
+  module Core
+    class OnePoleLP # :nodoc:
+      def initialize
+        @outputs = 0.0
+      end
+      
+      def run(input, cutoff)
+        p = (cutoff * 0.98) * (cutoff * 0.98) * (cutoff * 0.98) * (cutoff * 0.98);
+        @outputs = (1.0 - p) * input + p * @outputs
+      end
+    end
+  end
+end

data/lib/synth_blocks/core/oscillator.rb

@@ -0,0 +1,36 @@
+module SynthBlocks
+  module Core
+    ##
+    # simple  oscillator
+    # can currently do squarewave, sawtooth and sine
+    # this oscillator is not bandwidth limited and will thus alias like there's no tomorrow
+    class Oscillator
+      ##
+      # Create new oscillator
+      def initialize(sampling_frequency)
+        @sampling_frequency = sampling_frequency.to_f
+        @in_cycle = 0
+      end
+
+      # [frequency] Oscillator frequency in Hz (can be altered at any time)
+      # [pulse_width] pulse width, only in effect when creating a square wave
+      # [waveform] can be: :square (default), :sawtooth, :sine
+      def run(frequency, pulse_width: 0.5, waveform: :square)
+        period = @sampling_frequency / frequency.to_f
+        output = 0
+        if waveform == :square
+          output = @in_cycle > pulse_width ? -1.0 : 1.0
+        end
+        if waveform == :sawtooth
+          output = (@in_cycle * 2) - 1.0
+        end
+        if waveform == :sine
+          phase = @in_cycle * 2 * Math::PI
+          output = Math.sin(phase)
+        end
+        @in_cycle = (@in_cycle + (1.0 / period)) % 1.0
+        output
+      end
+    end
+  end
+end

data/lib/synth_blocks/core/sound.rb

@@ -0,0 +1,187 @@
+module SynthBlocks
+  module Core
+    ##
+    # Base class for all sound generators and the mixer channels
+    # Handles events (note on / off) and automation
+    # Has two modes, polyphonic and monophonic
+    class Sound
+      # Mode, either :monophonic or :polyphonic
+      attr_accessor :mode
+
+      # run the generator at offset (samples from song start)
+      def run(offset)
+        raise "Base Class, should not be called"
+      end
+
+      def live_params # :nodoc:
+        []
+      end
+
+      # this + start time makes it possible to delete events from list
+      #
+      # define this in your generator implementation if your generator has fixed
+      # note lengths not dependent on the note off event
+      # (for example one shot drum hits)
+      def duration(t=0)
+        nil
+      end
+
+      # this + end time makes it possible to delete events from list
+      #
+      # define this in your generator implementation if your generator is dependent
+      # on note off events
+      def release(t=0)
+        nil
+      end
+
+      ##
+      # create new sound generator instance
+      #
+      # <tt>super(sfreq, mode: $mode)</tt> should be called from the sound generator
+      # implementation initializer.
+
+      def initialize(sfreq, mode: :polyphonic)
+        @mode = mode
+        @sampling_frequency = sfreq.to_f
+        @parameters = {}
+        @events = []
+        @active_events = {}
+        initialize_live_params
+        @prepared = false
+        @sample_duration = 1.0 / @sampling_frequency
+      end
+
+      # create a note on event at time t with note and velocity
+      # [t] time in seconds from song start
+      # [note] MIDI note
+      # [velocity] velocity of note from 0 to 1.0
+      def start(t, note = 36, velocity = 1.0)
+        @events << [t.to_f, :start, note, velocity]
+      end
+
+      # create a note off event at time t with note
+      # [t] time in seconds from song start
+      # [note] MIDI note
+      def stop(t, note = 36)
+        @events << [t.to_f, :stop, note, 0]
+      end
+
+      ##
+      # returns active events at time t
+      def active_events(t)
+        if mode == :polyphonic
+          active_polyphonic_events(t)
+        else
+          active_monophonic_events(t)
+        end
+      end
+
+
+      # sets a parameter to a specific value at a given time.
+      # you can interpolate linearly between two points by setting to value A
+      # then setting value B at a later point in time with type: linear
+      # TODO: implement quadratic interpolation
+      #
+      # Note: this does no sanity checking, so please make sure you set events
+      # in the correct order etc.
+      # [parameter] parameter name
+      # [time] time in seconds from song start
+      # [value] value of the parameter you want to get to
+      # [type] either :set or :linear
+
+      def set(parameter, time, value, type: :set)
+        @parameters[parameter] ||= []
+        @parameters[parameter] << [time, value, type]
+        @parameters[parameter].sort_by! { |item| item.first }
+      end
+
+      # get the exact parameter value including interpolation
+      # [parameter] parameter name
+      # [time] time of from where you want the value
+      def get(parameter, time)
+        return nil if @parameters[parameter].nil?
+        return nil if @parameters[parameter].first.first > time
+        reverse_list = @parameters[parameter].reverse
+        reverse_list.each_with_index do |entry, index|
+          return entry[1] if entry.first <= time
+          if entry.first >= time && entry[2] == :linear
+            if reverse_list[index + 1].nil?
+              return nil
+            end
+            lin_time_start = reverse_list[index + 1][0]
+            lin_value_start = reverse_list[index + 1][1]
+            value_diff = entry[1] - lin_value_start
+            time_diff = entry[0] - lin_time_start
+            return value_diff / time_diff * (time - lin_time_start)
+          end
+        end
+      end
+
+      private
+
+      def initialize_live_params
+        live_params.each do |p|
+          set(p, 0, @preset[p], type: :set)
+        end
+      end
+
+      def time(offset)
+        offset.to_f / @sampling_frequency
+      end
+
+      def frequency(note)
+        (2.0 ** ((note.to_f - 69.0) / 12.0)) * 440.0
+      end
+
+      def prepare
+        return if @prepared
+        @events.sort_by! { |item| item.first }
+        @prepared = true
+      end
+
+      def filter_done_events(t)
+        return if duration(t).nil? && release(t).nil? # sound subclass needs to implement this to work
+        @active_events.reject! do |note, event|
+          # one shots with duration
+          duration(t) && event[:started] + duration(t) <= t ||
+          # stopped with release time
+          release(t) && event[:stopped] && event[:stopped] + release(t) <= t
+        end
+      end
+
+      # returns correct events for a monophonic synth with proper not priority.
+
+      def active_monophonic_events(t)
+        active_polyphonic_events(t)
+        non_stopped = @active_events.select { |note, event| event[:stopped].nil? }
+        unless non_stopped.empty?
+          return Hash[[non_stopped.sort_by{|note, event| event[:started] }.last]]
+        end
+        stopped = @active_events.sort_by{|note, event| event[:stopped]}.last
+        if stopped
+          Hash[[stopped]]
+        else
+          {}
+        end
+      end
+
+      def active_polyphonic_events(t)
+        t = t.to_f
+        prepare
+        @events.each_with_index do |event|
+          # let's look at the smallest interval possible
+          # pp [t.to_f, t.to_f + (@sample_duration * 2)]
+          next if event.first < t
+          break if event.first > t + (@sample_duration * 2)
+          if event[1] == :start
+            @active_events[event[2]] = {started: event[0], velocity: event[3]}
+          elsif event[1] == :stop
+            @active_events[event[2]][:stopped] = event[0] if @active_events[event[2]]
+          end
+        end
+        filter_done_events(t)
+        @active_events
+      end
+    end
+  end
+end

data/lib/synth_blocks/core/state_variable_filter.rb

@@ -0,0 +1,41 @@
+module SynthBlocks
+  module Core
+    # Simple State Variable filter
+    #
+    # source: http://www.musicdsp.org/en/latest/Filters/23-state-variable.html
+    # More info: https://www.earlevel.com/main/2003/03/02/the-digital-state-variable-filter/
+    class StateVariableFilter
+
+      ##
+      # Create new filter instance
+      def initialize(sfreq)
+        @sampling_frequency = sfreq.to_f
+        @delay_1 = 0.0
+        @delay_2 = 0.0
+      end
+
+      # run the filter from input value
+      # [frequency] cutoff freq in Hz
+      # [q] resonance, from 0 to ...
+      # [type] can be :lowpass, :highpass, :bandpass and :notch
+      def run(input, frequency, q, type: :lowpass)
+        # derived parameters
+        q1 = 1.0 / q.to_f
+        f1 = 2.0 * Math::PI * frequency.to_f / @sampling_frequency
+
+        # calculate filters
+        lowpass = @delay_2 + f1 * @delay_1
+        highpass = input - lowpass - q1 * @delay_1
+        bandpass = f1 * highpass + @delay_1
+        notch = highpass + lowpass
+
+        # store delays
+        @delay_1 = bandpass
+        @delay_2 = lowpass
+
+        results = { lowpass: lowpass, highpass: highpass, bandpass: bandpass, notch: notch }
+        results[type]
+      end
+    end
+  end
+end

data/lib/synth_blocks/core/wave_writer.rb

@@ -0,0 +1,28 @@
+require 'wavefile'
+
+module SynthBlocks
+  module Core
+    ##
+    # Writes Floating point data to a wavefile using the wave file gem
+    class WaveWriter
+      ##
+      # Static method to write to file given as first argument IF given
+      def self.write_if_name_given(samples)
+        if (ARGV[0])
+          WaveWriter.new(ARGV[0]).write(samples)
+        end
+      end
+
+      def initialize(filename)
+        @filename = filename
+      end
+
+      def write(float_data)
+        buffer = WaveFile::Buffer.new(float_data, WaveFile::Format.new(:mono, :float, 44100))
+        WaveFile::Writer.new(@filename, WaveFile::Format.new(:mono, :pcm_16, 44100)) do |writer|
+           writer.write(buffer)
+        end
+      end
+    end
+  end
+end

data/lib/synth_blocks/drum/hihat.rb

@@ -0,0 +1,54 @@
+require 'synth_blocks/core/state_variable_filter'
+require 'synth_blocks/mod/envelope'
+
+module SynthBlocks
+  module Drum
+    ##
+    # Simple Hihat generator
+    # Nois > Filter > Amp
+    class Hihat < SynthBlocks::Core::Sound
+      ##
+      # === parameters
+      # flt_frequency - center frequency of the bandpass filter
+      #
+      # flt_Q - Q (resonance) value of the bandpass filter
+      #
+      # amp_attack - attack time in seconds
+      #
+      # amp_decay - decay time in seconds
+      #
+      def initialize(sfreq, preset = {})
+        super(sfreq, mode: :polyphonic)
+        @filter = SynthBlocks::Core::StateVariableFilter.new(sfreq)
+        @preset = {
+          flt_frequency: 10000,
+          flt_Q: 2,
+          amp_attack: 0.001,
+          amp_decay: 0.1,
+        }.merge(preset)
+        @amp_env = SynthBlocks::Mod::Envelope.new(@preset[:amp_attack], @preset[:amp_decay])
+      end
+
+      def duration(_) # :nodoc:
+        @preset[:amp_attack] + @preset[:amp_decay]
+      end
+
+      # Run the generator (offset is given in samples)
+      def run(offset)
+        # time in seconds
+        t = time(offset)
+        events = active_events(t)
+        if events.empty?
+          0.0
+        else
+          event = events[events.keys.last]
+          # lfo_out = (@lfo.run(@preset[:lfo_frequency], waveform: @preset[:lfo_waveform]) + 1) / 8 + 0.5
+          local_started = t - event[:started]
+          noise_out = rand * 2.0 - 1.0
+          noise_out = @filter.run(noise_out, @preset[:flt_frequency], @preset[:flt_Q], type: :bandpass)
+          0.3 * noise_out * @amp_env.run(local_started)
+        end
+      end
+    end
+  end
+end