synth_blocks 1.0.0

data/lib/synth_blocks/fx/g_verb.rb

@@ -0,0 +1,275 @@
+module SynthBlocks
+  module Fx
+    # Direct port from GVerb
+    # Source: https://github.com/swh/lv2/blob/master/gverb/gverbdsp.c
+    # (and other files from that repo)
+    #
+    # Here's the original (c) notice from https://github.com/swh/lv2/blob/master/gverb/gverbdsp.c
+    #
+    #     Copyright (C) 1999 Juhana Sadeharju
+    #                    kouhia at nic.funet.fi
+    # This program is free software; you can redistribute it and/or modify
+    # it under the terms of the GNU General Public License as published by
+    # the Free Software Foundation; either version 2 of the License, or
+    # (at your option) any later version.
+    # This program is distributed in the hope that it will be useful,
+    # but WITHOUT ANY WARRANTY; without even the implied warranty of
+    # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    # GNU General Public License for more details.
+    # You should have received a copy of the GNU General Public License
+    # along with this program; if not, write to the Free Software
+    # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+    #
+
+    require 'prime'
+
+    class FixedDelay # :nodoc:
+      def initialize(size)
+        @size = size
+        @buf = Array.new(size)
+        @idx = 0
+        @buf = @buf.map { |e| 0.0 }
+      end
+
+      def read(n)
+        i = (@idx - n + @size) % @size;
+        @buf[i]
+      end
+
+      def write(x)
+        @buf[@idx] = x
+        @idx = (@idx + 1) % @size
+      end
+    end
+
+    class Damper # :nodoc:
+      def initialize(damping)
+        @damping = damping
+        @delay = 0.0
+      end
+
+      def run(x)
+        y = x * (1.0-@damping) + @delay * @damping;
+        @delay = y
+        y
+      end
+    end
+
+    class Diffuser # :nodoc:
+      def initialize(size, coeff)
+        @size = size.floor
+        @coeff = coeff
+        @idx = 0
+        @buf = Array.new(@size)
+        @buf = @buf.map { |e| 0.0 }
+      end
+
+      def run(x)
+        w = x - @buf[@idx] * @coeff;
+        y = @buf[@idx] + w * @coeff;
+        @buf[@idx] = w
+        @idx = (@idx + 1) % @size;
+        y
+      end
+    end
+    ##
+    # GVerb is a relatively simple reverb implementation
+    class GVerb
+      FDNORDER = 4 # :nodoc:
+
+
+      ##
+      # Create new GVerb instance
+      #
+      # max_room_size is the maximum room size you'll use
+      #
+      # room_size is the current room size
+      #
+      def initialize(srate, max_room_size: 120.0, room_size: 50.0, rev_time: 2.0, damping: 0.3, spread: 15.0, input_bandwidth: 1.5, early_level: 0.8, tail_level: 0.5, mix: 0.2)
+        @rate = srate
+        @damping = damping
+        @max_room_size = max_room_size
+        @room_size = room_size
+        @rev_time = rev_time
+        @early_level = early_level
+        @tail_level = tail_level
+        @mix = mix
+        @max_delay = @rate * @max_room_size / 340.0
+        @largest_delay = @rate * @room_size / 340.0
+        @input_bandwidth = input_bandwidth;
+        @input_damper = Damper.new(1.0 - @input_bandwidth)
+
+
+        @fdndels = FDNORDER.times.map do |i|
+          FixedDelay.new(@max_delay + 1000)
+        end
+        @fdngains = Array.new(FDNORDER)
+        @fdnlens = Array.new(FDNORDER)
+
+        @fdndamps = FDNORDER.times.map do |i|
+          Damper.new(@damping)
+        end
+
+        ga = 60.0;
+        gt = @rev_time;
+        ga = 10.0 ** (-ga / 20.0)
+        n = @rate * gt
+        @alpha = ga ** (1.0 / n)
+        gb = 0.0;
+        FDNORDER.times do |i|
+          gb = 1.000000*@largest_delay if (i == 0)
+          gb = 0.816490*@largest_delay if (i == 1)
+          gb = 0.707100*@largest_delay if (i == 2)
+          gb = 0.632450*@largest_delay if (i == 3)
+
+          @fdnlens[i] = nearest_prime(gb, 0.5);
+          @fdnlens[i] = gb.round;
+          @fdngains[i] = -(@alpha ** @fdnlens[i])
+        end
+
+        @d = Array.new(FDNORDER)
+        @u = Array.new(FDNORDER)
+        @f = Array.new(FDNORDER)
+
+        # DIFFUSER SECTION
+
+        diffscale = @fdnlens[3].to_f/(210+159+562+410);
+        spread1 = spread.to_f
+        spread2 = 3.0*spread
+
+        b = 210
+        r = 0.125541
+        a = spread1*r
+        c = 210+159+a
+        cc = c-b
+        r = 0.854046
+        a = spread2*r
+        d = 210+159+562+a
+        dd = d-c
+        e = 1341-d
+
+        @ldifs = [
+          Diffuser.new((diffscale*b),0.75),
+          Diffuser.new((diffscale*cc),0.75),
+          Diffuser.new((diffscale*dd),0.625),
+          Diffuser.new((diffscale*e),0.625)
+        ]
+
+        b = 210
+        r = -0.568366
+        a = spread1*r
+        c = 210+159+a
+        cc = c-b
+        r = -0.126815;
+        a = spread2*r
+        d = 210+159+562+a
+        dd = d-c
+        e = 1341-d
+
+        @rdifs = [
+          Diffuser.new((diffscale*b),0.75),
+          Diffuser.new((diffscale*cc),0.75),
+          Diffuser.new((diffscale*dd),0.625),
+          Diffuser.new((diffscale*e),0.625)
+        ]
+
+
+        # Tapped delay section */
+
+        @tapdelay = FixedDelay.new(44000)
+        @taps = Array.new(FDNORDER)
+        @tapgains = Array.new(FDNORDER)
+
+        @taps[0] = 5+0.410*@largest_delay
+        @taps[1] = 5+0.300*@largest_delay
+        @taps[2] = 5+0.155*@largest_delay
+        @taps[3] = 5+0.000*@largest_delay
+
+        FDNORDER.times do |i|
+          @tapgains[i] = @alpha ** @taps[i]
+        end
+      end
+
+
+      ##
+      # runs a value through the reverb, returns the reverberated signal
+      # mixed with the original.
+      def run(x)
+        if x.nan? || x.abs > 100000.0
+          x = 0.0
+        end
+
+        z = @input_damper.run(x)
+        z = @ldifs[0].run(z)
+        FDNORDER.times do |i|
+          @u[i] = @tapgains[i] * @tapdelay.read(@taps[i])
+        end
+
+        @tapdelay.write(z)
+
+        FDNORDER.times do |i|
+          @d[i] = @fdndamps[i].run(@fdngains[i] * @fdndels[i].read(@fdnlens[i]))
+        end
+
+        sum = 0.0
+        sign = 1.0
+        FDNORDER.times do |i|
+          sum += sign * (@tail_level * @d[i] + @early_level * @u[i])
+          sign = -sign
+        end
+
+        sum += x* @early_level
+
+        lsum = sum
+        # rsum = sum
+
+        @f = fdn_matrix(@d)
+
+        FDNORDER.times do |i|
+          @fdndels[i].write(@u[i] + @f[i])
+        end
+
+        lsum = @ldifs[1].run(lsum)
+        lsum = @ldifs[2].run(lsum)
+        lsum = @ldifs[3].run(lsum)
+
+        # rsum = @rdifs[1].run(rsum)
+        # rsum = @rdifs[2].run(rsum)
+        # rsum = @rdifs[3].run(rsum)
+
+        lsum = x * (1.0 - @mix) + lsum * @mix
+        # rsum = x * (1.0 - mix) + rsum * mix
+        return lsum
+      end
+
+
+      private
+
+      def nearest_prime(n_f, rerror)
+        n = n_f.to_i
+        return n if Prime.prime?(n)
+        # assume n is large enough and n*rerror enough smaller than n */
+        bound = n*rerror;
+        1.upto(bound) do |k|
+          return n+k if Prime.prime?(n+k)
+          return n-k if Prime.prime?(n-k)
+        end
+        return -1
+      end
+
+      def fdn_matrix(a)
+        b = Array.new(FDNORDER)
+        dl0 = a[0]
+        dl1 = a[1]
+        dl2 = a[2]
+        dl3 = a[3]
+
+        b[0] = 0.5*(dl0 + dl1 - dl2 - dl3);
+        b[1] = 0.5*(dl0 - dl1 - dl2 + dl3);
+        b[2] = 0.5*(-dl0 + dl1 - dl2 + dl3);
+        b[3] = 0.5*(dl0 + dl1 + dl2 + dl3);
+        b
+      end
+    end
+  end
+end

data/lib/synth_blocks/fx/limiter.rb

@@ -0,0 +1,15 @@
+module SynthBlocks
+  module Fx
+    ##
+    # Simple soft limiter
+    # Taken from https://github.com/pichenettes/stmlib/blob/448babb082dfe7b0a1ffbf0b349eefde64691b49/dsp/dsp.h#L97
+    class Limiter
+
+      ##
+      # run limiter
+      def run(x)
+        x * (27.0 + x * x) / (27.0 + 9.0 * x * x)
+      end
+    end
+  end
+end

data/lib/synth_blocks/fx/waveshaper.rb

@@ -0,0 +1,24 @@
+module SynthBlocks
+  module Fx
+    ##
+    # waveshaper, source http://www.musicdsp.org/en/latest/Effects/41-waveshaper.html
+    # amount can go from 1 to ... oo
+    # the higher a the stronger is the distortion
+    class Waveshaper
+      ##
+      # Waveshaper amount
+      attr_reader :amount
+      ##
+      # Create waveshaper instance
+      # [amount] Amount can be from 0 to oo
+      def initialize(amount)
+        @amount = amount
+      end
+      ##
+      # run waveshaper
+      def run(input)
+        input * (input.abs + amount) / (input ** 2 + (amount - 1) * input.abs + 1)
+      end
+    end
+  end
+end

data/lib/synth_blocks/mixer/mixer_channel.rb

@@ -0,0 +1,106 @@
+require 'synth_blocks/core/sound'
+
+module SynthBlocks
+  module Mixer
+    ##
+    # Emulation of a mixer channel on a mixing desk
+    # has a built in EQ, compressor and ducker, can run an arbitrary
+    # number of insert effects and send channels
+    class MixerChannel < SynthBlocks::Core::Sound
+      ##
+      # These params can be automated
+      LIVE_PARAMS = [:volume, :eq_low_gain, :eq_high_gain, :eq_mid_gain]
+      attr_accessor :preset # :nodoc:
+
+      def live_params # :nodoc:
+        LIVE_PARAMS
+      end
+
+      ##
+      # - source - Source sound generator
+      # - insert_effects - Array of effects instances
+      # - sends - Array of send values
+      # === Parameters
+      # - volume - channel volume
+      # - eq_low_freq, eq_high_freq - shelving frequencies for equalizer
+      # - eq_low_gain, eq_mid_gain, eq_high_gain - Equalizer gains per band
+      # - comp_threshold, comp_ratio, comp_attack, comp_release - Compressor params
+      # - duck - Duck amount (0-1)
+      # - duck attack, duck_release - Ducker envelope params in s
+      def initialize(srate, source, insert_effects: [], sends: [], preset: {})
+        @source = source
+        @insert_effects = insert_effects
+        @sends = sends
+        @preset = {
+          volume: 0.2,
+          eq_low_freq: 880,
+          eq_high_freq: 5000,
+          eq_low_gain: 1.0,
+          eq_mid_gain: 1.0,
+          eq_high_gain: 1.0,
+          comp_threshold: -50.0,
+          comp_ratio: 0.4,
+          comp_attack: 80.0,
+          comp_release: 200.0,
+          duck: 0.0,
+          duck_attack: 0.01,
+          duck_release: 0.5
+        }.merge(preset)
+
+        super(srate)
+        @ducks = []
+        @duck_env = SynthBlocks::Mod::Envelope.new(@preset[:duck_attack], @preset[:duck_release])
+        @eq = SynthBlocks::Fx::Eq.new(srate, lowfreq: @preset[:eq_low_freq], highfreq: @preset[:eq_high_freq])
+        @compressor = SynthBlocks::Fx::Compressor.new(srate, attack: @preset[:comp_attack], release: @preset[:comp_release], ratio: @preset[:comp_ratio], threshold: @preset[:comp_threshold])
+        update_live_params(0)
+      end
+
+      ##
+      # Schedule ducking at time t (in seconds)
+      def duck(t)
+        @ducks << t
+        @ducks.sort
+      end
+
+      ##
+      # returns send portion of output signal for send index
+      def send(index)
+        @output * (@sends[index] || 0.0)
+      end
+
+      ##
+      # runs channel
+      def run(offset)
+        t = time(offset)
+        update_live_params(t)
+        out = @eq.run(@source.run(offset))
+        @insert_effects.each do |effect|
+          out = effect.run(out)
+        end
+        if @preset[:duck] != 0.0
+          duck = current_duck(t)
+          if duck
+            local_duck = t - duck
+            out = out * (1.0 - @preset[:duck] * @duck_env.run(local_duck))
+          end
+        end
+        out = @compressor.run(out)
+        @output = out * @preset[:volume]
+      end
+
+      private
+
+      def update_live_params(t)
+        @eq.low_gain = get(:eq_low_gain, t)
+        @eq.mid_gain = get(:eq_low_gain, t)
+        @eq.high_gain = get(:eq_low_gain, t)
+      end
+
+      def current_duck(t)
+        past = @ducks.select {|duck| duck < t}
+        return past.last unless past.empty?
+        nil
+      end
+    end
+  end
+end

data/lib/synth_blocks/mixer/send_channel.rb

@@ -0,0 +1,25 @@
+require 'synth_blocks/mixer/mixer_channel'
+
+module SynthBlocks
+  module Mixer
+    ##t
+    # Channel subclass specifically for SendChannels
+    class SendChannel < MixerChannel
+      ##
+      # creates new send channel. See MixerChannel#new for parameters
+      def initialize(srate, insert_effects: [], sends: [], preset: {})
+        super(srate, nil, insert_effects: insert_effects, sends: sends, preset: preset)
+      end
+
+      ##
+      # run the send channel
+      def run(offset, input)
+        out = @eq.run(input)
+        @insert_effects.each do |effect|
+          out = effect.run(out)
+        end
+        @output = out * @preset[:volume]
+      end
+    end
+  end
+end