build_audulus_wavetable_node 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d02df36b06e903541294901c553cef80d7830f41
-  data.tar.gz: 281c8617db7cbd34ece938b92fb0a9f20acf3e43
+  metadata.gz: e3643e058d04f602f3abc06cc1546396fa81aa13
+  data.tar.gz: 633181be59ed58b990ab26f10b2d5cf8f4e2d3db
 SHA512:
-  metadata.gz: c23714863dca46f257e47356b52b58af7a48038c4ab5ee93e631ec226e7c12bd74d585a30c2ffb222d62157a5e0fc6e183150fe0faa0bf496db8168ad0edb1ec
-  data.tar.gz: ed944ee19c0ee119dda2429b62a9be2245037a6ad70e205c3b9604cc82313f7d061f85bdd30253b992829867ed85244867c07d64b88aea47b067a40c85178c18
+  metadata.gz: c3a585230dbd27317319aca2fff9088745e66d3171f1bbf45f906ada2180b1e16367c71ba3f893c59fed00be68542419ef8f56ba20614d4788ecc90b59958a46
+  data.tar.gz: cdba3131032642ec1c337b7dc82300a370aa3cf38476b1a16c36d560462a5f9680d85a35bdcfa5e51f7cdeb9cb8acd82707e3aaabce2efa9f9451e7c1218b8ce

data/bin/build_audulus_wavetable_node

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'build_audulus_wavetable_node'
-command(ARGV)
+require 'command'
+Command.run(ARGV)
 

data/lib/antialias.rb

@@ -0,0 +1,41 @@
+require 'fftw3'
+
+class Antialias
+  # sample_rate, Hz, e.g. 44100
+  # fundamental, Hz, e.g. 440
+  # samples: -1..1
+  # The sample_rate gives us the Nyquist limit, and the fundamental
+  # tells us how to calculate the partials to find out which ones fall
+  # above the Nyquist limit. With this knowledge we dampen those higher
+  # partials for the purpose of preventing aliases at that fundamental.
+  def self.antialias_for_fundamental(sample_rate, fundamental, samples)
+    fft = FFTW3.fft(NArray[samples]).to_a.flatten
+    dampened = dampen_higher_partials(sample_rate, fundamental, fft)
+    (FFTW3.ifft(NArray[dampened]) / samples.count).real.to_a.flatten
+  end
+
+  # kill everything higher than a scaled nyquist limit
+  # ease in/out everything else to minimize partials near nyquist
+  def self.dampen_higher_partials(sample_rate, fundamental, fft)
+    nyquist = sample_rate.to_f / 2
+    sample_fundamental = sample_rate.to_f / fft.count
+    scaled_nyquist = nyquist / fundamental * sample_fundamental
+    sample_duration = fft.count.to_f / sample_rate
+    sub_nyquist_sample_count = scaled_nyquist * sample_duration
+    fft.each_with_index.map {|power, i|
+      hz = i.to_f / fft.count * sample_rate.to_f
+      if hz < scaled_nyquist
+        scale_partial(i, sub_nyquist_sample_count, power)
+      else
+        0+0i
+      end
+    }
+  end
+
+  # dampen partials higher than a certain frequency using a smooth
+  # "ease-in-out" shape
+  def self.scale_partial(partial_index, partial_count, partial_value)
+    partial_value * (Math.cos(partial_index.to_f*Math::PI/2/partial_count)**2)
+  end
+end
+

data/lib/audulus.rb

@@ -2,189 +2,202 @@ require 'json'
 require 'yaml'
 require 'securerandom'
 
-def uuid?(string)
-  string.kind_of?(String) && /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/ =~ string
-end
+module Audulus
+  module_function
 
-# Node -> [ UUID ]
-def scan_uuids(node)
-  case node
-  when Hash
-    node.map {|key, elem|
-      if uuid?(elem)
-        elem
-      else
-        scan_uuids(elem)
-      end
-    }.flatten
-  when Array
-    node.map {|elem| scan_uuids(elem)}.flatten
-  else
-    []
+  def uuid?(string)
+    string.kind_of?(String) && /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/ =~ string
   end
-end
 
-def build_uuid_map(node)
-  existing_uuids = scan_uuids(node)
-  existing_uuids.reduce({}) {|h, uuid|
-    h[uuid] = SecureRandom.uuid()
-    h
-  }
-end
+  # Node -> [ UUID ]
+  def scan_uuids(node)
+    case node
+    when Hash
+      node.map {|key, elem|
+        if uuid?(elem)
+          elem
+        else
+          scan_uuids(elem)
+        end
+      }.flatten
+    when Array
+      node.map {|elem| scan_uuids(elem)}.flatten
+    else
+      []
+    end
+  end
 
-def clone_node(node)
-  uuid_map = build_uuid_map(node)
-  clone_node_helper(node, uuid_map)
-end
+  def build_uuid_map(node)
+    existing_uuids = scan_uuids(node)
+    existing_uuids.reduce({}) {|h, uuid|
+      h[uuid] = SecureRandom.uuid()
+      h
+    }
+  end
 
-def clone_node_helper(node, uuid_map)
-  case node
-  when Hash
-    Hash[node.map {|key, elem|
-      if uuid?(elem)
-        [key, uuid_map[elem]]
-      else
-        [key, clone_node_helper(elem, uuid_map)]
-      end
-    }]
-  when Array
-    node.map {|elem|
-      clone_node_helper(elem, uuid_map)
+  def clone_node(node)
+    uuid_map = build_uuid_map(node)
+    clone_node_helper(node, uuid_map)
+  end
+
+  def clone_node_helper(node, uuid_map)
+    case node
+    when Hash
+      Hash[node.map {|key, elem|
+        if uuid?(elem)
+          [key, uuid_map[elem]]
+        else
+          [key, clone_node_helper(elem, uuid_map)]
+        end
+      }]
+    when Array
+      node.map {|elem|
+        clone_node_helper(elem, uuid_map)
+      }
+    else
+      node
+    end
+  end
+
+  def add_node(patch, node)
+    patch['nodes'] << node
+    patch
+  end
+
+  def add_nodes(patch, nodes)
+    nodes.each do |node|
+      add_node(patch, node)
+    end
+  end
+
+  def move_node(node, x, y)
+    node['position'] = {
+      'x' => x,
+      'y' => y,
     }
-  else
     node
   end
-end
 
-def add_node(patch, node)
-  patch['nodes'] << node
-  patch
-end
-
-def add_nodes(patch, nodes)
-  nodes.each do |node|
-    add_node(patch, node)
+  def expose_node(node, x, y)
+    node['exposedPosition'] = {
+      'x' => x,
+      'y' => y,
+    }
+    node
   end
-end
 
-def move_node(node, x, y)
-  node['position'] = {
-    'x' => x,
-    'y' => y,
-  }
-  node
-end
+  def wire_output_to_input(patch, source_node, source_output, destination_node, destination_input)
+    patch['wires'] << {
+      "from" => source_node['id'],
+      "output" => source_output,
+      "to" => destination_node['id'],
+      "input": destination_input
+    }
+  end
 
-def expose_node(node, x, y)
-  node['exposedPosition'] = {
-    'x' => x,
-    'y' => y,
-  }
-  node
-end
+  def build_init_doc
+    result = clone_node(INIT_PATCH)
+    result
+  end
 
-def wire_output_to_input(patch, source_node, source_output, destination_node, destination_input)
-  patch['wires'] << {
-    "from" => source_node['id'],
-    "output" => source_output,
-    "to" => destination_node['id'],
-    "input": destination_input
-  }
-end
+  def make_subpatch(subpatch)
+    doc = build_init_doc
+    patch = doc['patch']
 
-def build_init_doc
-  result = clone_node(INIT_PATCH)
-  result
-end
+    subpatch_node = build_subpatch_node
+    subpatch_node['subPatch'] = subpatch
+    add_node(patch, subpatch_node)
+    doc
+  end
 
-def make_subpatch(subpatch)
-  doc = build_init_doc
-  patch = doc['patch']
+  def build_light_node
+    clone_node(LIGHT_NODE)
+  end
 
-  subpatch_node = build_subpatch_node
-  subpatch_node['subPatch'] = subpatch
-  add_node(patch, subpatch_node)
-  doc
-end
+  def build_trigger_node
+    clone_node(TRIGGER_NODE)
+  end
 
-def build_light_node
-  clone_node(LIGHT_NODE)
-end
+  def build_subpatch_node
+    clone_node(SUBPATCH_NODE)
+  end
 
-def build_trigger_node
-  clone_node(TRIGGER_NODE)
-end
+  # gate output is output 0
+  def build_clock_node
+    clone_node(CLOCK_NODE)
+  end
 
-def build_subpatch_node
-  clone_node(SUBPATCH_NODE)
-end
+  def build_via_node
+    clone_node(VIA_NODE)
+  end
 
-# gate output is output 0
-def build_clock_node
-  clone_node(CLOCK_NODE)
-end
+  def build_input_node
+    clone_node(INPUT_NODE)
+  end
 
-def build_via_node
-  clone_node(VIA_NODE)
-end
+  def build_output_node
+    result = build_simple_node("Output")
+    result['name'] = "Output"
+    result
+  end
 
-def build_input_node
-  clone_node(INPUT_NODE)
-end
+  def build_knob_node
+    result = build_simple_node("Knob")
+    result['knob'] = {
+      'value' => 0.5,
+      'min' => 0.0,
+      'max' => 1.0,
+    }
+    expose_node(result, 0, 0)
+    result
+  end
 
-def build_output_node
-  result = build_simple_node("Output")
-  result['name'] = "Output"
-  result
-end
+  def build_sample_and_hold_node
+    build_simple_node("Sample & Hold")
+  end
 
-def build_knob_node
-  result = build_simple_node("Knob")
-  result['knob'] = {
-    'value' => 0.5,
-    'min' => 0.0,
-    'max' => 1.0,
-  }
-  expose_node(result, 0, 0)
-  result
-end
+  def build_mux_node
+    build_simple_node("Mux8")
+  end
 
-def build_sample_and_hold_node
-  build_simple_node("Sample & Hold")
-end
+  def build_demux_node
+    build_simple_node("Demux8")
+  end
 
-def build_mux_node
-  build_simple_node("Mux8")
-end
+  def build_expr_node(expr)
+    result = build_simple_node('Expr')
+    result['expr'] = expr
+    result
+  end
 
-def build_demux_node
-  build_simple_node("Demux8")
-end
+  def build_text_node(text)
+    result = build_simple_node("Text")
+    result['text'] = text
+    result
+  end
 
-def build_expr_node(expr)
-  result = build_simple_node('Expr')
-  result['expr'] = expr
-  result
-end
+  def build_simple_node(type)
+    clone_node({
+      "type" => type,
+      "id" => "7e5486fc-994c-44f0-ae83-5ebba54d7e3b",
+      "position" => {
+        "x" => 0,
+        "y" => 0
+      }
+    })
+  end
 
-def build_text_node(text)
-  result = build_simple_node("Text")
-  result['text'] = text
-  result
-end
+  XMUX_NODE = JSON.parse(File.read(File.join(File.dirname(__FILE__), 'xmux.audulus')))['patch']['nodes'][0]
+  def build_xmux_node
+    clone_node(XMUX_NODE)
+  end
 
-def build_simple_node(type)
-  clone_node({
-    "type" => type,
-    "id" => "7e5486fc-994c-44f0-ae83-5ebba54d7e3b",
-    "position" => {
-      "x" => 0,
-      "y" => 0
-    }
-  })
-end
+  O2HZ_NODE = JSON.parse(File.read(File.join(File.dirname(__FILE__), 'o2Hz.audulus')))['patch']['nodes'][0]
+  def build_o2hz_node
+    clone_node(O2HZ_NODE)
+  end
 
-INIT_PATCH = YAML.load <<YAML
+  INIT_PATCH = YAML.load <<-YAML
 ---
 version: 1
 patch:
@@ -195,18 +208,18 @@ patch:
   zoom: 1.0
   nodes: []
   wires: []
-YAML
+  YAML
 
-LIGHT_NODE = YAML.load <<YAML
+  LIGHT_NODE = YAML.load <<-YAML
 ---
 type: Light
 id: b264602f-365b-48a2-9d25-9b95055a2c34
 position:
   x: 0.0
   y: 0.0
-YAML
+  YAML
 
-TRIGGER_NODE = JSON.parse <<JSON
+  TRIGGER_NODE = JSON.parse <<-JSON
 {
   "type": "Trigger",
   "id": "3e8e612d-3b7a-4c6d-a2ea-2e5f1a00161d",
@@ -217,9 +230,9 @@ TRIGGER_NODE = JSON.parse <<JSON
   "toggle": false,
   "state": false
 }
-JSON
+  JSON
 
-INPUT_NODE = JSON.parse <<JSON
+  INPUT_NODE = JSON.parse <<-JSON
 {
   "type": "Input",
   "id": "3e8e612d-3b7a-4c6d-a2ea-2e5f1a00161d",
@@ -233,9 +246,9 @@ INPUT_NODE = JSON.parse <<JSON
   },
   "name": "input"
 }
-JSON
+  JSON
 
-SUBPATCH_NODE = JSON.parse <<JSON
+  SUBPATCH_NODE = JSON.parse <<-JSON
 {
   "type": "Patch",
   "id": "0fe72e0e-2616-4366-8036-f852398d1c73",
@@ -254,7 +267,8 @@ SUBPATCH_NODE = JSON.parse <<JSON
     "wires": []
   }
 }
-JSON
+  JSON
 
-CLOCK_NODE = JSON.parse(File.read(File.join(File.dirname(__FILE__), 'clock.json')))
-VIA_NODE = JSON.parse(File.read(File.join(File.dirname(__FILE__), 'via.audulus')))['patch']['nodes'][0]
+  CLOCK_NODE = JSON.parse(File.read(File.join(File.dirname(__FILE__), 'clock.json')))
+  VIA_NODE = JSON.parse(File.read(File.join(File.dirname(__FILE__), 'via.audulus')))['patch']['nodes'][0]
+end

data/lib/build_audulus_wavetable_node.rb

@@ -1,348 +1 @@
-"""
-The following code builds an Audulus wavetable node given a single cycle waveform.
-
-The way it works is by building a spline node corresponding to the waveform, then
-building the support patch to drive a Phasor node at the desired frequency into the
-spline node to generate the output.
-
-The complexity in the patch comes from the fact that for any wavetable you will
-quickly reach a point where you are generating harmonics that are beyond the Nyquist
-limit. Without diving into details, the problem with this is that it will cause
-aliasing, or frequencies that are not actually part of the underlying waveform.
-These usually sound bad and one usually doesn't want them.
-
-The solution is as follows (glossing over important details):
-1. determine a set of frequency bands we care about. In my case, 0-55Hz, and up by
-   octaves for 8 octaves
-2. for each frequency band, run the waveform through a Fast Fourier Transform
-3. attenuate frequencies higher than the Nyquist limit for that frequency band
-4. run an inverse FFT to get a new waveform
-5. generate a wavetable for each frequency band
-6. generate support patch to make sure the right wavetable is chosen for a given
-   frequency
-
-Steps 2–4 behave like a very precise single-pole non-resonant low-pass-filter, and
-I probably could have used that, but this approach was more direct.
-"""
-
-
-require 'json'
-
-# Load the library for building Audulus patches programmatically.
-require_relative 'audulus'
-
-class Sox
-  # load the WAV file at `path` and turn it into a list of samples,
-  # -1 to 1 in value
-  def self.load_samples(path)
-    `sox "#{path}" -t dat -`.
-      lines.
-      reject {|l| l.start_with?(';')}.
-      map(&:strip).
-      map(&:split).
-      map(&:last).
-      map(&:to_f)
-  end
-end
-
-class WavetablePatch
-  # Take a list of samples corresponding to a single cycle wave form
-  # and generate an Audulus patch with a single wavetable node that
-  # has title1 and title2 as title and subtitle
-  def self.build_patch(samples, title1, title2)
-    # The below code lays out the Audulus nodes as needed to build
-    # the patch. It should mostly be familiar to anyone who's built
-    # an Audulus patch by hand.
-    doc = build_init_doc
-    patch = doc['patch']
-
-    title1_node = build_text_node(title1)
-    move_node(title1_node, -700, 300)
-    expose_node(title1_node, -10, -30)
-
-    add_node(patch, title1_node)
-
-    title2_node = build_text_node(title2)
-    move_node(title2_node, -700, 250)
-    expose_node(title2_node, -10, -45)
-
-    add_node(patch, title2_node)
-
-    o_input_node = build_input_node
-    o_input_node['name'] = ''
-    move_node(o_input_node, -700, 0)
-    expose_node(o_input_node, 0, 0)
-    add_node(patch, o_input_node)
-
-    o2hz_node = build_o2hz_node
-    move_node(o2hz_node, -700, -100)
-    add_node(patch, o2hz_node)
-
-    wire_output_to_input(patch, o_input_node, 0, o2hz_node, 0)
-
-    hertz_node = build_expr_node('clamp(hz, 0.0001, 12000)')
-    move_node(hertz_node, -700, -200)
-    add_node(patch, hertz_node)
-
-    wire_output_to_input(patch, o2hz_node, 0, hertz_node, 0)
-
-    phaser_node = build_simple_node('Phasor')
-    move_node(phaser_node, -500, 0)
-    add_node(patch, phaser_node)
-
-    wire_output_to_input(patch, hertz_node, 0, phaser_node, 0)
-
-    domain_scale_node = build_expr_node('x/2/pi')
-    move_node(domain_scale_node, -300, 0)
-    add_node(patch, domain_scale_node)
-
-    wire_output_to_input(patch, phaser_node, 0, domain_scale_node, 0)
-
-    # for each frequency band, resample using the method outlined above
-    frequencies = (0..7).map {|i| 55*2**i}
-    sample_sets = frequencies.map {|frequency|
-      Resample.resample_for_fundamental(44100, frequency, samples)
-    }
-
-    # normalize the samples
-    normalization_factor = 1.0 / sample_sets.flatten.map(&:abs).max
-    normalized_sample_sets = sample_sets.map {|sample_set|
-      sample_set.map {|sample| sample*normalization_factor}
-    }
-
-    # generate the actual spline nodes corresponding to each wavetable
-    spline_nodes =
-      normalized_sample_sets.each_with_index.map {|samples, i|
-        spline_node = build_spline_node_from_samples(samples)
-        move_node(spline_node, -100, i*200)
-        spline_node
-      }
-
-    add_nodes(patch, spline_nodes)
-
-    spline_nodes.each do |spline_node|
-      wire_output_to_input(patch, domain_scale_node, 0, spline_node, 0)
-    end
-
-    # generate the "picker," the node that determines which wavetable
-    # to used based on the desired output frequency
-    spline_picker_node = build_expr_node("clamp(log2(hz/55), 0, 8)")
-    move_node(spline_picker_node, -100, -100)
-    add_node(patch, spline_picker_node)
-
-    mux_node = build_xmux_node
-    move_node(mux_node, 400, 0)
-    add_node(patch, mux_node)
-
-    spline_nodes.each_with_index do |spline_node, i|
-      wire_output_to_input(patch, spline_node, 0, mux_node, i+1)
-    end
-
-    wire_output_to_input(patch, hertz_node, 0, spline_picker_node, 0)
-    wire_output_to_input(patch, spline_picker_node, 0, mux_node, 0)
-
-    range_scale_node = build_expr_node('x*2-1')
-    move_node(range_scale_node, 600, 0)
-    add_node(patch, range_scale_node)
-
-    wire_output_to_input(patch, mux_node, 0, range_scale_node, 0)
-
-    output_node = build_output_node
-    output_node['name'] = ''
-    move_node(output_node, 1100, 0)
-    expose_node(output_node, 50, 0)
-    add_node(patch, output_node)
-
-    wire_output_to_input(patch, range_scale_node, 0, output_node, 0)
-
-    doc
-  end
-
-  def self.build_spline_node_from_samples(samples)
-    spline_node = build_simple_node("Spline")
-    spline_node["controlPoints"] = samples.each_with_index.map {|sample, i|
-      {
-        "x" => i.to_f/(samples.count-1).to_f,
-        "y" => (sample+1)/2,
-      }
-    }
-#    move_node(spline_node, -100, i*200)
-    spline_node
-  end
-
-  XMUX_NODE = JSON.parse(File.read(File.join(File.dirname(__FILE__), 'xmux.audulus')))['patch']['nodes'][0]
-  def self.build_xmux_node
-    clone_node(XMUX_NODE)
-  end
-
-  O2HZ_NODE = JSON.parse(File.read(File.join(File.dirname(__FILE__), 'o2Hz.audulus')))['patch']['nodes'][0]
-  def self.build_o2hz_node
-    clone_node(O2HZ_NODE)
-  end
-end
-
-class Resample
-  require 'fftw3'
-  # sample_rate, Hz, e.g. 44100
-  # fundamental, Hz, e.g. 440
-  # samples: -1..1
-  def self.resample_for_fundamental(sample_rate, fundamental, samples)
-    fft = FFTW3.fft(NArray[samples]).to_a.flatten
-    dampened = dampen_higher_partials(sample_rate, fundamental, fft)
-    (FFTW3.ifft(NArray[dampened]) / samples.count).real.to_a.flatten
-  end
-
-  # kill everything higher than a scaled nyquist limit
-  # ease in/out everything else to minimize partials near nyquist
-  def self.dampen_higher_partials(sample_rate, fundamental, fft)
-    nyquist = sample_rate.to_f / 2
-    sample_fundamental = sample_rate.to_f / fft.count
-    scaled_nyquist = nyquist / fundamental * sample_fundamental
-    sample_duration = fft.count.to_f / sample_rate
-    sub_nyquist_sample_count = scaled_nyquist * sample_duration
-    fft.each_with_index.map {|power, i|
-      hz = i.to_f / fft.count * sample_rate.to_f
-      if hz < scaled_nyquist
-        scale_partial(i, sub_nyquist_sample_count, power)
-      else
-        0+0i
-      end
-    }
-  end
-
-  # dampen partials higher than a certain frequency using a smooth
-  # "ease-in-out" shape
-  def self.scale_partial(partial_index, partial_count, partial_value)
-    partial_value * (Math.cos(partial_index.to_f*Math::PI/2/partial_count)**2)
-  end
-end
-
-# Given a path to a single-cycle-waveform wav file, generate an Audulus wavetable
-# node
-def build_wavetable_patch_from_wav_file(path)
-  patch_data = build_patch_data(path)
-
-  # build the patch as a full patch
-  base_patch = WavetablePatch.build_patch(patch_data[:samples], patch_data[:title1], patch_data[:title2])['patch']
-
-  # wrap it up as a subpatch
-  final_patch = make_subpatch(base_patch)
-
-  # write the patch to a file as JSON (the format Audulus uses)
-  File.write(patch_data[:output_path], JSON.generate(final_patch))
-end
-
-# Build just a spline from the given samples. Intended for automation rather than
-# for wavetables.
-def build_spline_patch_from_wav_file(path)
-  patch_data = build_patch_data(path)
-
-  doc = build_init_doc
-  patch = doc['patch']
-  spline_node = WavetablePatch.build_spline_node_from_samples(patch_data[:samples])
-  add_node(patch, spline_node)
-
-  File.write(patch_data[:output_path], JSON.generate(doc))
-end
-
-def build_patch_data(path)
-  # break the path into directory and path so we can build the audulus file's name
-  parent, file = path.split("/")[-2..-1]
-
-  # load the samples from the WAV file
-  samples = Sox.load_samples(path)
-
-  # build the audulus patch name from the WAV file name
-  basename = File.basename(file, ".wav")
-  puts "building #{basename}.audulus"
-  audulus_patch_name = "#{basename}.audulus"
-
-  { :output_path => audulus_patch_name,
-    :samples => samples,
-    :title1 => parent,
-    :title2 => basename,
-  }
-end
-
-# Make a set of random samples. Useful for generating a cyclic
-# noise wavetable. This method would be used in place of loading
-# the WAV file.
-def make_random_samples(count)
-  count.times.map {
-    rand*2-1
-  }
-end
-
-# Make a set of samples conforming to a parabola. This method would
-# be used in place of loading the WAV file.
-def make_parabolic_samples(count)
-  f = ->(x) { -4*x**2 + 4*x }
-  count.times.map {|index|
-    index.to_f / (count-1)
-  }.map(&f).map {|sample|
-    sample*2-1
-  }
-end
-
-# Given a set of samples, build the Audulus wavetable node
-def build_patch_from_samples(samples, title1, title2, output_path)
-  puts "building #{output_path}"
-  File.write(output_path, JSON.generate(make_subpatch(WavetablePatch.build_patch(samples, title1, title2)['patch'])))
-end
-
-require 'optparse'
-
-def parse_arguments!(argv)
-  results = {
-    :spline_only => false
-  }
-  option_parser = OptionParser.new do |opts|
-    opts.banner = "build_audulus_wavetable_node [OPTIONS] WAV_FILE"
-
-    opts.on("-h", "--help", "Prints this help") do
-      results[:help] = opts.help
-    end
-
-    opts.on("-s", "--spline-only", "generate a patch containing only a spline corresponding to the samples in the provided WAV file") do
-      results[:spline_only] = true
-    end
-  end
-
-  option_parser.parse!(argv)
-  if argv.count != 1
-    results = {
-      :help => option_parser.help
-    }
-  end
-
-  results[:input_filename] = argv[0]
-
-  results
-end
-
-def command(argv)
-  arguments = argv.dup
-  options = parse_arguments!(arguments)
-  if options.has_key?(:help)
-    puts options[:help]
-    exit(0)
-  end
-
-  path = options[:input_filename]
-  unless File.exist?(path)
-    puts "Cannot find WAV file at #{path}"
-    exit(1)
-  end
-
-  if options[:spline_only]
-    build_spline_patch_from_wav_file(path)
-  else
-    build_wavetable_patch_from_wav_file(path)
-  end
-end
-
-# This code is the starting point.. if we run this file as
-# its own program, do the following
-if __FILE__ == $0
-  command(ARGV)
-end
+raise "Not suitable for library use yet"

data/lib/command.rb

@@ -0,0 +1,99 @@
+require 'optparse'
+
+require_relative 'audulus'
+require_relative 'sox'
+require_relative 'wavetable_patch'
+require_relative 'spline_patch'
+require_relative 'midi_patch'
+require_relative 'spline_helper'
+
+module Command
+  def self.build_patch_data(path, title, subtitle)
+    # break the path into directory and path so we can build the audulus file's name
+    parent, file = path.split("/")[-2..-1]
+
+    # load the samples from the WAV file
+    samples = Sox.load_samples(path)
+
+    # build the audulus patch name from the WAV file name
+    basename = File.basename(file, ".wav")
+    puts "building #{basename}.audulus"
+    audulus_patch_name = "#{basename}.audulus"
+
+    results = { :output_path => audulus_patch_name,
+                :samples     => samples,
+                :title       => title,
+                :subtitle    => subtitle, }
+
+    results[:title]    ||= parent
+    results[:subtitle] ||= basename
+
+    results
+  end
+
+  def self.parse_arguments!(argv)
+    results = {
+      :spline_only => false
+    }
+    option_parser = OptionParser.new do |opts|
+      opts.banner = "build_audulus_wavetable_node [OPTIONS] WAV_FILE"
+
+      opts.on("-h", "--help", "Prints this help") do
+        results[:help] = opts.help
+      end
+
+      opts.on("-s", "--spline", "generate a patch containing only a spline corresponding to the samples in the provided WAV file") do
+        results[:spline_only] = true
+      end
+
+      opts.on("-m", "--midi", "generate a patch containing two splines based on the provided MIDI file") do |t|
+        results[:midi] = true
+      end
+
+      opts.on("-tTITLE", "--title=TITLE", "provide a title for the patch (defaults to parent directory)") do |t|
+        results[:title] = t
+      end
+
+      opts.on("-uSUBTITLE", "--subtitle=SUBTITLE", "provide a subtitle for the patch (defaults to file name, minus .wav)") do |u|
+        results[:subtitle] = u
+      end
+    end
+
+    option_parser.parse!(argv)
+    if argv.count != 1
+      results = {
+        :help => option_parser.help
+      }
+    end
+
+    results[:input_filename] = argv[0]
+
+    results
+  end
+
+  def self.run(argv)
+    arguments = argv.dup
+    options = parse_arguments!(arguments)
+    if options.has_key?(:help)
+      puts options[:help]
+      exit(0)
+    end
+
+    path = options[:input_filename]
+    unless File.exist?(path)
+      puts "Cannot find WAV file at #{path}"
+      exit(1)
+    end
+
+
+    if options[:spline_only]
+      patch_data = build_patch_data(path, options[:title], options[:subtitle])
+      SplinePatch.build_patch(patch_data)
+    elsif options[:midi]
+      MidiPatch.build_patch(path)
+    else
+      patch_data = build_patch_data(path, options[:title], options[:subtitle])
+      WavetablePatch.build_patch(patch_data)
+    end
+  end
+end

data/lib/midi_patch.rb

@@ -0,0 +1,103 @@
+require 'midilib'
+require_relative 'audulus'
+require_relative 'spline_helper'
+require 'pry'
+
+module MidiPatch
+  def self.build_patch(path)
+    seq = MIDI::Sequence.new()
+
+    File.open(path, 'rb') do |file|
+      seq.read(file)
+    end
+
+    doc = Audulus.build_init_doc
+    patch = doc['patch']
+
+    pitch_node = build_pitch_node(seq)
+    Audulus.add_node(patch, pitch_node)
+    Audulus.move_node(pitch_node, 0, 0)
+
+    scaler_node = Audulus.build_expr_node('x*10-5')
+    Audulus.add_node(patch, scaler_node)
+    Audulus.move_node(scaler_node, 425, 55)
+    Audulus.wire_output_to_input(patch, pitch_node, 0, scaler_node, 0)
+
+    pitch_label = Audulus.build_text_node("pitch")
+    Audulus.add_node(patch, pitch_label)
+    Audulus.move_node(pitch_label, -50, 100)
+
+    gate_node = build_gate_node(seq)
+    Audulus.add_node(patch, gate_node)
+    Audulus.move_node(gate_node, 0, 200)
+
+    pitch_label = Audulus.build_text_node("gate")
+    Audulus.add_node(patch, pitch_label)
+    Audulus.move_node(pitch_label, -50, 300)
+
+    _, file = File.expand_path(path).split("/")[-2..-1]
+    basename = File.basename(file, ".mid")
+    File.write("#{basename}.audulus", JSON.generate(doc))
+  end
+
+  def self.build_pitch_node(seq)
+    note_on_events = seq.first.select {|e| MIDI::NoteOn === e}
+
+    times = note_on_events.map(&:time_from_start)
+    min_time, max_time = [times.min, times.max].map(&:to_f)
+    scaled_times = times.map {|time|
+      scale_time(time, min_time, max_time)
+    }
+
+    notes = note_on_events.map(&:note)
+    scaled_notes = notes.map {|note|
+      one_per_octave = (note.to_f - 69.0)/12.0
+      (one_per_octave+5)/10 # scale to be > 0
+    }
+
+    coordinates = scaled_times.zip(scaled_notes)
+    SplineHelper.build_spline_node_from_coordinates(coordinates)
+  end
+
+  def self.build_gate_node(seq)
+    note_on_off_events = seq.first.select {|e| MIDI::NoteOn === e || MIDI::NoteOff === e}
+
+    note_stack = []
+
+    times = note_on_off_events.map(&:time_from_start)
+    min_time, max_time = [times.min, times.max].map(&:to_f)
+    coordinates = note_on_off_events.map {|event|
+      time = scale_time(event.time_from_start, min_time, max_time)
+      case event
+      when MIDI::NoteOn
+        add_to_stack(note_stack, event)
+        [time, scale_velocity(event.velocity)]
+      when MIDI::NoteOff
+        remove_from_stack(note_stack, event)
+        if note_stack.empty?
+          [time, 0.0]
+        else
+          [time, scale_velocity(note_stack[-1].velocity)]
+        end
+      end
+    }
+
+    SplineHelper.build_spline_node_from_coordinates(coordinates)
+  end
+
+  def self.scale_time(time, min_time, max_time)
+    (time - min_time).to_f / (max_time - min_time).to_f
+  end
+
+  def self.scale_velocity(velocity)
+    velocity.to_f / 127.0
+  end
+
+  def self.add_to_stack(stack, event)
+    stack << event
+  end
+
+  def self.remove_from_stack(stack, event)
+    stack.delete_if {|e| e.note == event.note}
+  end
+end

data/lib/sample_generator.rb

@@ -0,0 +1,21 @@
+module SampleGenerator
+  # Make a set of random samples. Useful for generating a cyclic
+  # noise wavetable. This method would be used in place of loading
+  # the WAV file.
+  def make_random_samples(count)
+    count.times.map {
+      rand*2-1
+    }
+  end
+
+  # Make a set of samples conforming to a parabola. This method would
+  # be used in place of loading the WAV file.
+  def make_parabolic_samples(count)
+    f = ->(x) { -4*x**2 + 4*x }
+    count.times.map {|index|
+      index.to_f / (count-1)
+    }.map(&f).map {|sample|
+      sample*2-1
+    }
+  end
+end

data/lib/sox.rb

@@ -0,0 +1,14 @@
+class Sox
+  # load the WAV file at `path` and turn it into a list of samples,
+  # -1 to 1 in value
+  def self.load_samples(path)
+    `sox "#{path}" -t dat -`.
+      lines.
+      reject {|l| l.start_with?(';')}.
+      map(&:strip).
+      map(&:split).
+      map(&:last).
+      map(&:to_f)
+  end
+end
+

data/lib/spline_helper.rb

@@ -0,0 +1,24 @@
+require_relative 'audulus'
+
+module SplineHelper
+  # samples: list of values 0..1, assumed to be evenly spaced
+  # along the X axis
+  def self.build_spline_node_from_samples(samples)
+    coordinates = samples.each_with_index.map {|sample, i|
+      [i.to_f/(samples.count-1).to_f, sample]
+    }
+    build_spline_node_from_coordinates(coordinates)
+  end
+
+  # coordinates: list of x,y pairs, where x in [0..1] and y in [0..1]
+  def self.build_spline_node_from_coordinates(coordinates)
+    spline_node = Audulus.build_simple_node("Spline")
+    spline_node["controlPoints"] = coordinates.map { |x, sample|
+      {
+        "x" => x,
+        "y" => sample.to_f,
+      }
+    }
+    spline_node
+  end
+end

data/lib/spline_patch.rb

@@ -0,0 +1,13 @@
+module SplinePatch
+  # Build just a spline from the given samples. Intended for automation rather than
+  # for wavetables.
+  def self.build_patch(patch_data)
+    doc = Audulus.build_init_doc
+    patch = doc['patch']
+    scaled_samples = patch_data[:samples].map {|sample| (sample.to_f + 1.0)/2.0}
+    spline_node = SplineHelper.build_spline_node_from_samples(scaled_samples)
+    Audulus.add_node(patch, spline_node)
+
+    File.write(patch_data[:output_path], JSON.generate(doc))
+  end
+end

data/lib/wavetable_patch.rb

@@ -0,0 +1,159 @@
+# The following code builds an Audulus wavetable node given a single cycle waveform.
+#
+# The way it works is by building a spline node corresponding to the waveform, then
+# building the support patch to drive a Phasor node at the desired frequency into the
+# spline node to generate the output.
+#
+# The complexity in the patch comes from the fact that for any wavetable you will
+# quickly reach a point where you are generating harmonics that are beyond the Nyquist
+# limit. Without diving into details, the problem with this is that it will cause
+# aliasing, or frequencies that are not actually part of the underlying waveform.
+# These usually sound bad and one usually doesn't want them.
+#
+# The solution is as follows (glossing over important details):
+# 1. determine a set of frequency bands we care about. In my case, 0-55Hz, and up by
+   # octaves for 8 octaves
+# 2. for each frequency band, run the waveform through a Fast Fourier Transform
+# 3. attenuate frequencies higher than the Nyquist limit for that frequency band
+# 4. run an inverse FFT to get a new waveform
+# 5. generate a wavetable for each frequency band
+# 6. generate support patch to make sure the right wavetable is chosen for a given
+   # frequency
+#
+# Steps 2–4 behave like a very precise single-pole non-resonant low-pass-filter, and
+# I probably could have used that, but this approach was more direct.
+
+require_relative 'antialias'
+
+class WavetablePatch
+  class <<self
+    include Audulus
+  end
+
+  # Take a list of samples corresponding to a single cycle wave form
+  # and generate an Audulus patch with a single wavetable node that
+  # has title1 and title2 as title and subtitle
+  def self.build_patch_helper(samples, title1, title2)
+    # The below code lays out the Audulus nodes as needed to build
+    # the patch. It should mostly be familiar to anyone who's built
+    # an Audulus patch by hand.
+    doc = build_init_doc
+    patch = doc['patch']
+
+    title1_node = build_text_node(title1)
+    move_node(title1_node, -700, 300)
+    expose_node(title1_node, -10, -30)
+
+    add_node(patch, title1_node)
+
+    title2_node = build_text_node(title2)
+    move_node(title2_node, -700, 250)
+    expose_node(title2_node, -10, -45)
+
+    add_node(patch, title2_node)
+
+    o_input_node = build_input_node
+    o_input_node['name'] = ''
+    move_node(o_input_node, -700, 0)
+    expose_node(o_input_node, 0, 0)
+    add_node(patch, o_input_node)
+
+    o2hz_node = build_o2hz_node
+    move_node(o2hz_node, -700, -100)
+    add_node(patch, o2hz_node)
+
+    wire_output_to_input(patch, o_input_node, 0, o2hz_node, 0)
+
+    hertz_node = build_expr_node('clamp(hz, 0.0001, 12000)')
+    move_node(hertz_node, -700, -200)
+    add_node(patch, hertz_node)
+
+    wire_output_to_input(patch, o2hz_node, 0, hertz_node, 0)
+
+    phaser_node = build_simple_node('Phasor')
+    move_node(phaser_node, -500, 0)
+    add_node(patch, phaser_node)
+
+    wire_output_to_input(patch, hertz_node, 0, phaser_node, 0)
+
+    domain_scale_node = build_expr_node('x/2/pi')
+    move_node(domain_scale_node, -300, 0)
+    add_node(patch, domain_scale_node)
+
+    wire_output_to_input(patch, phaser_node, 0, domain_scale_node, 0)
+
+    # for each frequency band, resample using the method outlined above
+    frequencies = (0..7).map {|i| 55*2**i}
+    sample_sets = frequencies.map {|frequency|
+      Antialias.antialias_for_fundamental(44100, frequency, samples)
+    }
+
+    # normalize the samples
+    normalization_factor = 1.0 / sample_sets.flatten.map(&:abs).max
+    normalized_sample_sets = sample_sets.map {|sample_set|
+      sample_set.map {|sample| sample*normalization_factor}
+    }
+
+    # generate the actual spline nodes corresponding to each wavetable
+    spline_nodes =
+      normalized_sample_sets.each_with_index.map {|sample_set, i|
+        scaled_samples = sample_set.map {|sample| (sample.to_f + 1.0)/2.0}
+        spline_node = SplineHelper.build_spline_node_from_samples(scaled_samples)
+        move_node(spline_node, -100, i*200)
+        spline_node
+      }
+
+    add_nodes(patch, spline_nodes)
+
+    spline_nodes.each do |spline_node|
+      wire_output_to_input(patch, domain_scale_node, 0, spline_node, 0)
+    end
+
+    # generate the "picker," the node that determines which wavetable
+    # to used based on the desired output frequency
+    spline_picker_node = build_expr_node("clamp(log2(hz/55), 0, 8)")
+    move_node(spline_picker_node, -100, -100)
+    add_node(patch, spline_picker_node)
+
+    mux_node = build_xmux_node
+    move_node(mux_node, 400, 0)
+    add_node(patch, mux_node)
+
+    spline_nodes.each_with_index do |spline_node, i|
+      wire_output_to_input(patch, spline_node, 0, mux_node, i+1)
+    end
+
+    wire_output_to_input(patch, hertz_node, 0, spline_picker_node, 0)
+    wire_output_to_input(patch, spline_picker_node, 0, mux_node, 0)
+
+    range_scale_node = build_expr_node('x*2-1')
+    move_node(range_scale_node, 600, 0)
+    add_node(patch, range_scale_node)
+
+    wire_output_to_input(patch, mux_node, 0, range_scale_node, 0)
+
+    output_node = build_output_node
+    output_node['name'] = ''
+    move_node(output_node, 1100, 0)
+    expose_node(output_node, 50, 0)
+    add_node(patch, output_node)
+
+    wire_output_to_input(patch, range_scale_node, 0, output_node, 0)
+
+    doc
+  end
+
+  # Given a path to a single-cycle-waveform wav file, generate an Audulus wavetable
+  # node
+  def self.build_patch(patch_data)
+    # build the patch as a full patch
+    base_patch = build_patch_helper(patch_data[:samples], patch_data[:title], patch_data[:subtitle])['patch']
+
+    # wrap it up as a subpatch
+    final_patch = Audulus.make_subpatch(base_patch)
+
+    # write the patch to a file as JSON (the format Audulus uses)
+    File.write(patch_data[:output_path], JSON.generate(final_patch))
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: build_audulus_wavetable_node
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jimmy Thrasher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-16 00:00:00.000000000 Z
+date: 2018-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fftw3
@@ -24,6 +24,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: midilib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
 description: ''
 email: jimmy@jimmythrasher.com
 executables:
@@ -32,11 +60,19 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/build_audulus_wavetable_node
+- lib/antialias.rb
 - lib/audulus.rb
 - lib/build_audulus_wavetable_node.rb
 - lib/clock.json
+- lib/command.rb
+- lib/midi_patch.rb
 - lib/o2Hz.audulus
+- lib/sample_generator.rb
+- lib/sox.rb
+- lib/spline_helper.rb
+- lib/spline_patch.rb
 - lib/via.audulus
+- lib/wavetable_patch.rb
 - lib/xmux.audulus
 homepage: https://github.com/jjthrash/audulus_wave_table
 licenses: