synth_blocks 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 482e3c24341fafb72b3f095bf688799a37a26e6559835c149b8b7db0670cd2f2
-  data.tar.gz: 28046f996d3b9b7f7fc9ecdf183253f37257339ccf9ba37cd4f1361d74e2f1df
+  metadata.gz: d9e4c687fc841d59a5e910589e7cd8d584ad84bc6079ef508a02969afb547690
+  data.tar.gz: 7f3e2170fb0559f07b151784b16e835f032d10ab397b49ebc7477d5026aef3c4
 SHA512:
-  metadata.gz: 2d5684ff0b78c0705a8625a3fd863f67988eb11d96a025d308e0f4f3a8999c2ed5cd2927dea6ec9503db44c812ea4717488a46d482e54ca3f61d9ede35ed44cd
-  data.tar.gz: 871e845e0ecd1eb1e6b4a7ec82ac92971b841c99646eb004651276a4f42087b6905942902f5265a84968973d3edf2405ee93343b5397afe6f39e2fc17ddb0ef5
+  metadata.gz: a0a01ec77eb1d4b51ad402f82f3566e2ca9f79d37eb13eb27d5c9702f077c8c1da06b079afe248d1c710025285ac2db24a0d33e4dd6d43674b58f6a68c1682d5
+  data.tar.gz: fe8407848935beac13adb2f90a01a38762ebd0692d2f1265f1e24ff7813d0534c030ed58756ae81e092d8a3165cbbf7c82784608defda93bcaef3bfc16b3ed50

data/README.md

@@ -19,6 +19,17 @@ The code is super unoptimised, as it is written for learning purposes. This mean
 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.
 
+## Opal
+
+Since my presentation runs in a browser I thought it could be fun to try to make this library run in Opal and thus in the browser.
+
+It works but obviously long running code that will block the main thread is not something that makes browsers (and users) happy, but for small demonstrations, it's probably good enough.
+
+There are two modules that do not work:
+
+- GVerb uses prime numbers but Opal does not implement Stdlib::Prime.
+- To prevent adding WaveFile as an additional dependency (and because it doesn't make a ton of sense for my usecase), WaveWriter is not functional in Opal.
+
 ## Examples
 
 The easiest way to test the example code is to check out the repo and then execute the code directly.

data/lib/synth_blocks.rb

@@ -1,24 +1,35 @@
-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'
+require_relative 'synth_blocks/core/sound'
+require_relative 'synth_blocks/mod/adsr'
+require_relative 'synth_blocks/fx/chorus'
+require_relative 'synth_blocks/fx/compressor'
+require_relative 'synth_blocks/fx/delay'
+require_relative 'synth_blocks/mod/envelope'
+require_relative 'synth_blocks/fx/eq'
+require_relative 'synth_blocks/fx/g_verb'
+require_relative 'synth_blocks/drum/hihat'
+require_relative 'synth_blocks/drum/kick_drum'
+require_relative 'synth_blocks/drum/tuned_drum'
+require_relative 'synth_blocks/mixer/mixer_channel'
+require_relative 'synth_blocks/synth/monosynth'
+require_relative 'synth_blocks/core/moog_filter'
+require_relative 'synth_blocks/core/oscillator'
+require_relative 'synth_blocks/synth/polysynth'
+require_relative 'synth_blocks/mixer/send_channel'
+require_relative 'synth_blocks/sequencer/sequencer_dsl'
+require_relative 'synth_blocks/drum/snare_drum'
+require_relative 'synth_blocks/core/state_variable_filter'
+require_relative 'synth_blocks/utils'
+require_relative 'synth_blocks/fx/waveshaper'
+require_relative 'synth_blocks/fx/limiter'
+require_relative 'synth_blocks/core/wave_writer'
+
+unless RUBY_ENGINE == 'opal'
+  # Now if we are NOT running inside of opal, set things up so opal can find
+  # the files. The whole thing is rescued in case the opal gem is not available.
+  # This would happen if the gem is being used server side ONLY.
+  begin
+    require 'opal'
+    Opal.append_path File.expand_path('..', __FILE__).untaint
+  rescue LoadError
+  end
+end

data/lib/synth_blocks/core/wave_writer.rb

@@ -1,26 +1,33 @@
-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)
+    if RUBY_ENGINE == 'opal'
+      class WaveWriter
+        def self.write_if_name_given(samples)
+          raise "Not Implemented in OPAL"
         end
       end
+    else
+      require 'wavefile'
+      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 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)
+        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

data/lib/synth_blocks/fx/g_verb.rb

@@ -21,254 +21,265 @@ module SynthBlocks
     # 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
+    if RUBY_ENGINE != 'opal'
 
-    class Damper # :nodoc:
-      def initialize(damping)
-        @damping = damping
-        @delay = 0.0
-      end
+      require 'prime'
 
-      def run(x)
-        y = x * (1.0-@damping) + @delay * @damping;
-        @delay = y
-        y
-      end
-    end
+      class FixedDelay # :nodoc:
+        def initialize(size)
+          @size = size
+          @buf = Array.new(size)
+          @idx = 0
+          @buf = @buf.map { |e| 0.0 }
+        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 read(n)
+          i = (@idx - n + @size) % @size;
+          @buf[i]
+        end
 
-      def run(x)
-        w = x - @buf[@idx] * @coeff;
-        y = @buf[@idx] + w * @coeff;
-        @buf[@idx] = w
-        @idx = (@idx + 1) % @size;
-        y
+        def write(x)
+          @buf[@idx] = x
+          @idx = (@idx + 1) % @size
+        end
       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)
+      class Damper # :nodoc:
+        def initialize(damping)
+          @damping = damping
+          @delay = 0.0
         end
-        @fdngains = Array.new(FDNORDER)
-        @fdnlens = Array.new(FDNORDER)
 
-        @fdndamps = FDNORDER.times.map do |i|
-          Damper.new(@damping)
+        def run(x)
+          y = x * (1.0-@damping) + @delay * @damping;
+          @delay = y
+          y
         end
+      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])
+      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
 
-        @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]
+        def run(x)
+          w = x - @buf[@idx] * @coeff;
+          y = @buf[@idx] + w * @coeff;
+          @buf[@idx] = w
+          @idx = (@idx + 1) % @size;
+          y
         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
+      # 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
 
-        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)
+        ##
+        # 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
 
-        FDNORDER.times do |i|
-          @d[i] = @fdndamps[i].run(@fdngains[i] * @fdndels[i].read(@fdnlens[i]))
-        end
+          z = @input_damper.run(x)
+          z = @ldifs[0].run(z)
+          FDNORDER.times do |i|
+            @u[i] = @tapgains[i] * @tapdelay.read(@taps[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
+          @tapdelay.write(z)
 
-        sum += x* @early_level
+          FDNORDER.times do |i|
+            @d[i] = @fdndamps[i].run(@fdngains[i] * @fdndels[i].read(@fdnlens[i]))
+          end
 
-        lsum = sum
-        # rsum = sum
+          sum = 0.0
+          sign = 1.0
+          FDNORDER.times do |i|
+            sum += sign * (@tail_level * @d[i] + @early_level * @u[i])
+            sign = -sign
+          end
 
-        @f = fdn_matrix(@d)
+          sum += x* @early_level
 
-        FDNORDER.times do |i|
-          @fdndels[i].write(@u[i] + @f[i])
-        end
+          lsum = sum
+          # rsum = sum
 
-        lsum = @ldifs[1].run(lsum)
-        lsum = @ldifs[2].run(lsum)
-        lsum = @ldifs[3].run(lsum)
+          @f = fdn_matrix(@d)
 
-        # rsum = @rdifs[1].run(rsum)
-        # rsum = @rdifs[2].run(rsum)
-        # rsum = @rdifs[3].run(rsum)
+          FDNORDER.times do |i|
+            @fdndels[i].write(@u[i] + @f[i])
+          end
 
-        lsum = x * (1.0 - @mix) + lsum * @mix
-        # rsum = x * (1.0 - mix) + rsum * mix
-        return lsum
-      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)
+        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
-        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
+        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
+    else
+      class GVerb
+        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)
+        end
+        def run(x)
+          x
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: synth_blocks
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Jan Krutisch