synth_blocks 1.0.0

data/lib/synth_blocks/drum/kick_drum.rb

@@ -0,0 +1,54 @@
+require 'synth_blocks/core/sound'
+require 'synth_blocks/core/oscillator'
+require 'synth_blocks/mod/envelope'
+
+module SynthBlocks
+  module Drum
+    ##
+    # A simple kick drum generator
+    class KickDrum < SynthBlocks::Core::Sound
+
+      ##
+      # === Structure
+      # Pitch Env > Sine wave OSC >
+      #
+      # === parameter:
+      # - pitch_attack, pitch_decay - Pitch envelope params in s
+      # - amp_attack, amp_decay - Amp envelope params in s
+      # - base_frequency - base frequency in Hz
+      # - pitch_mod - frequency modulation amount in Hz
+      def initialize(sfreq, preset = {})
+        super(sfreq, mode: :polyphonic)
+        @preset = {
+          pitch_attack: 0.001,
+          pitch_decay: 0.05,
+          amp_attack: 0.001,
+          amp_decay: 0.1,
+          base_frequency: 50,
+          pitch_mod: 200
+        }.merge(preset)
+        @oscillator = SynthBlocks::Core::Oscillator.new(@sampling_frequency)
+        @pitch_env = SynthBlocks::Mod::Envelope.new(@preset[:pitch_attack], @preset[:pitch_decay])
+        @amp_env = SynthBlocks::Mod::Envelope.new(@preset[:amp_attack], @preset[:amp_decay])
+      end
+
+      def duration(_) # :nodoc:
+        @preset[:amp_attack] + @preset[:amp_decay]
+      end
+      ##
+      # Run generator
+      def run(offset)
+        t = time(offset)
+        events = active_events(t)
+        if events.empty?
+          0.0
+        else
+          event = events[events.keys.last]
+          local_started = t - event[:started]
+          osc_out = @oscillator.run(@preset[:base_frequency].to_f + @pitch_env.run(local_started) * @preset[:pitch_mod].to_f, waveform: :sine)
+          osc_out = osc_out * 1.0 * @amp_env.run(local_started)
+        end
+      end
+    end
+  end
+end

data/lib/synth_blocks/drum/snare_drum.rb

@@ -0,0 +1,87 @@
+require 'synth_blocks/core/sound'
+require 'synth_blocks/core/state_variable_filter'
+require 'synth_blocks/drum/kick_drum'
+require 'synth_blocks/mod/envelope'
+
+module SynthBlocks
+  module Drum
+    ##
+    # Simple snare drum generator
+    class SnareDrum < SynthBlocks::Core::Sound
+      ##
+      # === Parameters
+      # [flt_frequency] Noise filter frequency
+      # [flt_envmod] Noise filter frequency modulation by envelope
+      # [flt_attack, flt_decay] Noise filter envelope params
+      # [flt_Q] Noise filter Q/resonance
+      # [noise_amp_attack, noise_amp_decay] Noise amp envelope params
+      # [noise_vol, drum_vol] Noise and Drum body volumes
+      # [base_frequency] Drum body base frequency (see KickDrum#initialize)
+      # [pitch_mod] Drum body pitch mod (see KickDrum#initialize)
+      # [pitch_attack, pitch_decay] Drum body pitch env params
+      #
+      def initialize(sfreq, preset = {})
+        super(sfreq, mode: :polyphonic)
+        @preset = {
+          flt_frequency: 4000,
+          flt_envmod: 6000,
+          flt_attack: 0.001,
+          flt_decay: 0.1,
+          flt_Q: 2,
+          noise_amp_attack: 0.001,
+          noise_amp_decay: 0.15,
+          noise_vol: 0.5,
+          drum_vol: 0.3,
+          base_frequency: 200,
+          pitch_mod: 200,
+          pitch_decay: 0.07
+
+        }.merge(preset)
+        @drum = SynthBlocks::Drum::KickDrum.new(sfreq, @preset)
+        @filter = SynthBlocks::Core::StateVariableFilter.new(sfreq)
+        @flt_env = SynthBlocks::Mod::Envelope.new(@preset[:flt_attack], @preset[:flt_decay])
+        @amp_env = SynthBlocks::Mod::Envelope.new(@preset[:noise_amp_attack], @preset[:noise_amp_decay])
+      end
+
+      # create a note on event
+      # [t] time in seconds since song start
+      # [note] MIDI note number
+      # [velocity] velocity (currently unused)
+      def start(t, note = 36, velocity = 1.0)
+        super(t, note, velocity)
+        @drum.start(t, note, velocity)
+      end
+
+      # create a note off event
+      # [t] time in seconds since song start
+      # [note] MIDI note number
+      def stop(t, note = 36)
+        super(t, note)
+        @drum.stop(t, note)
+      end
+
+      def duration(t) # :nodoc:
+        [@preset[:noise_amp_attack] + @preset[:noise_amp_decay], @drum.duration(t)].max
+      end
+
+      # run the generator
+      def run(offset)
+        drum_out = @drum.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
+          noise_out = rand * 2.0 - 1.0
+          local_started = t - event[:started]
+          noise_out = @filter.run(noise_out, @preset[:flt_frequency] + @flt_env.run(local_started) * @preset[:flt_envmod], @preset[:flt_Q])
+          noise_out = 0.3 * noise_out * @amp_env.run(local_started)
+          noise_out * @preset[:noise_vol] + drum_out * @preset[:drum_vol]
+        end
+      end
+    end
+  end
+end

data/lib/synth_blocks/drum/tuned_drum.rb

@@ -0,0 +1,25 @@
+require 'synth_blocks/drum/kick_drum'
+
+module SynthBlocks
+  module Drum
+    ##
+    # Special case of the kick drum that allows to run it from a note pattern to
+    # create percussive sounds
+    class TunedDrum < KickDrum
+      def run(offset)
+        t = time(offset)
+        events = active_events(t)
+        if events.empty?
+          0.0
+        else
+          event = events[events.keys.last]
+          note = events.keys.last
+          base_freq = frequency(note)
+          local_started = t - event[:started]
+          osc_out = @oscillator.run(base_freq + @pitch_env.run(local_started) * @preset[:pitch_mod].to_f, waveform: :sine)
+          osc_out = osc_out * 1.0 * @amp_env.run(local_started)
+        end
+      end
+    end
+  end
+end

data/lib/synth_blocks/fx/chorus.rb

@@ -0,0 +1,85 @@
+require 'synth_blocks/core/one_pole_lowpass'
+
+module SynthBlocks
+  module Fx
+    ##
+    # A simple chorus
+    class Chorus
+      ##
+      attr_writer :phase, :rate, :delay_time, :mix # :nodoc:
+      ##
+      # Create new Chorus instance
+      #
+      # phase allows you to shift the phase of the delayed signal additionally
+      #
+      # rate is the LFO rate in Hz
+      #
+      # delay_time is the maximum delay time in ms
+      #
+      # mix is the ratio between original and delayed signal. 1.0 would mean only
+      # delayed signal (which wouldn't make any sense)
+      def initialize(sample_rate, phase: 0.0, rate: 0.5, delay_time: 7.0, mix: 0.5)
+        @sample_rate = sample_rate
+        @rate = rate
+        @delay_time = delay_time
+        @mix = mix
+
+        @z1 = 0.0
+        @sign = 0
+        @lfo_phase = phase * 2.0 - 1.0
+        @lfo_step_size = (4.0 * @rate / @sample_rate)
+        @lfo_sign = 1.0
+
+        # Compute required buffer size for desired delay and allocate it
+        # Add extra point to aid in interpolation later
+        @delay_line_length = ((@delay_time * @sample_rate * 0.001).floor * 2).to_i
+        @delay_line = [0.0] * @delay_line_length
+        @write_ptr = @delay_line_length - 1
+        @lp = SynthBlocks::Core::OnePoleLP.new
+        @output = 0.0
+      end
+
+      ##
+      # run the chorus
+      def run(input)
+        # Get delay time
+        offset = (next_lfo() * 0.3 + 0.4) * @delay_time * @sample_rate * 0.001
+
+        # Compute the largest read pointer based on the offset.  If ptr
+        # is before the first delayline location, wrap around end point
+        ptr = @write_ptr - offset.floor;
+        ptr += @delay_line_length - 1 if ptr < 0
+
+
+        ptr2 = ptr - 1
+        ptr2 += @delay_line_length - 1 if ptr2 < 0
+
+        frac = offset - offset.floor.to_f
+        @output = @delay_line[ptr2] + @delay_line[ptr] * (1.0 - frac) - (1.0 - frac) * @z1
+        @z1 = @output
+
+        # Low pass
+        @lp.run(@output, 0.95)
+
+        # Write the input sample and any feedback to delayline
+        @delay_line[@write_ptr] = input
+
+        # Increment buffer index and wrap if necesary
+        @write_ptr += 1
+        @write_ptr = 0 if @write_ptr >= @delay_line_length
+        return (@output * @mix) + (input * (1.0-@mix))
+      end
+
+      private
+
+      def next_lfo()
+        if @lfo_phase >= 1.0
+          @lfo_sign = -1.0
+        elsif @lfo_phase <= -1.0
+          @lfo_sign = 1.0
+        end
+        @lfo_phase += @lfo_step_size * @lfo_sign
+      end
+    end
+  end
+end

data/lib/synth_blocks/fx/compressor.rb

@@ -0,0 +1,121 @@
+module SynthBlocks
+  module Fx
+
+    class EnvelopeDetector # :nodoc:
+      def initialize(srate, tc: ms)
+        @sample_rate = srate
+        @ms = tc
+        set_coef()
+      end
+
+      def set_coef
+        @coef = Math.exp( -1000.0 / ( @ms * @sample_rate) )
+      end
+
+      def tc=(tc)
+        @ms = tc
+        set_coef()
+      end
+
+      def run(input, state)
+        input + @coef * ( state - input )
+      end
+    end
+
+
+    class AttRelEnvelope # :nodoc:
+      def initialize(srate, attack:, release:)
+        @attack = EnvelopeDetector.new(srate, tc: attack)
+        @release = EnvelopeDetector.new(srate, tc: release)
+      end
+
+      def attack=(attack)
+        @attack.tc = attack
+      end
+
+      def release=(decay)
+        @release.tc = decay
+      end
+
+      def run(input, state)
+        if input > state
+          @attack.run( input, state )
+        else
+          @release.run( input, state )
+        end
+      end
+    end
+
+    ##
+    # simple compresor
+    # taken from http://www.musicdsp.org/en/latest/Effects/204-simple-compressor-class-c.html
+
+    class Compressor
+      DC_OFFSET = 1.0E-25 # :nodoc:
+      LOG_2_DB = 8.6858896380650365530225783783321 # :nodoc:
+      DB_2_LOG = 0.11512925464970228420089957273422 # :nodoc:
+      attr_writer :ratio, :threshold, :window # :nodoc:
+      ##
+      # Create compressor instance
+      #
+      # attack is the attack time in ms
+      #
+      # release is the release time in ms
+      #
+      # ratio is the compresor ratio
+      #
+      # threshold is the knee threshold
+      def initialize(srate, attack: 10.0, release: 100.0, ratio: 1.0, threshold: 0.0)
+        @sample_rate = srate
+        @envelope = AttRelEnvelope.new(srate, attack: attack, release: release)
+        @env_db = DC_OFFSET
+        @ratio = ratio
+        @threshold = threshold
+      end
+
+      ##
+      # set attack
+      def attack=(attack)
+        @envelope.attack = attack
+      end
+
+      ##
+      # set release
+      def release=(release)
+        @envelope.release = release
+      end
+
+
+      ##
+      # run compressor
+      def run(input)
+        rect = input.abs
+        rect += DC_OFFSET
+        key_db = lin2db(rect)
+
+        over_db = key_db - @threshold
+        over_db = 0.0 if over_db < 0.0
+
+        # attack/release
+        over_db += DC_OFFSET
+        @env_db = @envelope.run(over_db, @env_db)
+        over_db = @env_db - DC_OFFSET
+
+        gr = over_db * @ratio - 1.0
+        gr = db2lin(gr)
+        input * gr
+      end
+
+      private
+
+      def lin2db(lin)
+        return Math.log( lin ) * LOG_2_DB
+      end
+
+      def db2lin(db)
+        return Math.exp( db * DB_2_LOG )
+      end
+
+    end
+  end
+end

data/lib/synth_blocks/fx/delay.rb

@@ -0,0 +1,42 @@
+module SynthBlocks
+  module Fx
+    ##
+    # Simple delay with mix and feedback parameters
+    # Currently doesn't really have a variable delay time, I'll tackle that when I
+    # need it. It uses a simple ring buffer implementation and delay time is only
+    # exact down to the sample.
+    class Delay
+      attr_reader :mix, :feedback # :nodoc:
+
+      ##
+      # time is given in seconds
+      #
+      # mix (0 = no delay, 1 = only delay)
+      #
+      # feedback (0 = zero feedback, 1 = full feedback (not advised))
+      #
+      # if given a block it will call the block from the run method to process the
+      # feedback signal
+      def initialize(sample_rate, time: 0.2, mix: 0.5, feedback: 0.4, &block)
+        @buffer = Array.new((sample_rate.to_f * time).floor)
+        @block = block
+        @pointer = 0
+        @mix = mix
+        @feedback = feedback
+      end
+
+      ##
+      # run delay
+      def run(input)
+        old_pointer = @pointer
+        @pointer = (@pointer + 1) % @buffer.length
+        delayed = (@buffer[@pointer] || 0.0)
+        if @block
+          delayed = @block.call(delayed)
+        end
+        @buffer[old_pointer] = input + (feedback * delayed)
+        input * (1.0 - mix) + delayed * mix
+      end
+    end
+  end
+end

data/lib/synth_blocks/fx/eq.rb

@@ -0,0 +1,92 @@
+module SynthBlocks
+  module Fx
+    ##
+    # Simple 3 band Equalizer with variable shelving frequencies
+    #
+    # Source: http://www.musicdsp.org/en/latest/Filters/236-3-band-equaliser.html
+    class Eq
+      VSA = 1.0 / 4294967295.0 # very small amount (Denormal fix) :nodoc:
+
+      attr_accessor :low_gain, :mid_gain, :high_gain # :nodoc: Low Gain, Mid Gain, High Gain
+
+      ##
+      # Create new Equalizer instance
+      #
+      # lowfreq and highfreq are the shelving frequencies in Hz
+      def initialize(sample_rate=44100, lowfreq: 880, highfreq: 5000)
+
+        # Poles Lowpass
+        @f1p0 = 0.0
+        @f1p1 = 0.0
+        @f1p2 = 0.0
+        @f1p3 = 0.0
+
+        # Poles Highpass
+        @f2p0 = 0.0
+        @f2p1 = 0.0
+        @f2p2 = 0.0
+        @f2p3 = 0.0
+
+        # Sample history buffer
+
+        @sdm1 = 0.0 # Sample data minus 1
+        @sdm2 = 0.0 #                   2
+        @sdm3 = 0.0 #                   3
+
+        # Gain Controls
+        # Set Low/Mid/High gains to unity
+
+        @low_gain  = 1.0       # low  gain
+        @mid_gain  = 1.0       # mid  gain
+        @high_gain = 1.0       # high gain
+
+        # Calculate filter cutoff frequencies
+
+        @lf = 2 * Math.sin(Math::PI * (lowfreq.to_f / sample_rate.to_f))
+        @hf = 2 * Math.sin(Math::PI * (highfreq.to_f / sample_rate.to_f))
+      end
+
+      ##
+      # run equalizer
+      def run(sample)
+        # Filter #1 (lowpass)
+
+        @f1p0  += (@lf * (sample - @f1p0)) + VSA;
+        @f1p1  += (@lf * (@f1p0 - @f1p1));
+        @f1p2  += (@lf * (@f1p1 - @f1p2));
+        @f1p3  += (@lf * (@f1p2 - @f1p3));
+
+        l = @f1p3;
+
+        # Filter #2 (highpass)
+
+        @f2p0  += (@hf * (sample   - @f2p0)) + VSA;
+        @f2p1  += (@hf * (@f2p0 - @f2p1));
+        @f2p2  += (@hf * (@f2p1 - @f2p2));
+        @f2p3  += (@hf * (@f2p2 - @f2p3));
+
+        h = @sdm3 - @f2p3;
+
+        # Calculate midrange (signal - (low + high))
+
+        m = @sdm3 - (h + l);
+
+        # Scale, Combine and store
+
+        l *= @low_gain
+        m *= @mid_gain
+        h *= @high_gain
+
+        # Shuffle history buffer
+
+        @sdm3   = @sdm2;
+        @sdm2   = @sdm1;
+        @sdm1   = sample;
+
+        # Return result
+
+        l + m + h
+      end
+    end
+  end
+end