build_audulus_nodes 0.5.0

data/lib/command.rb

@@ -0,0 +1,179 @@
+require 'optparse'
+require 'csv'
+
+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_from_wav_file(path, title=nil, subtitle=nil)
+    # 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")
+    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.build_patch_data_from_csv_file(path)
+    basename = File.basename(path, ".csv")
+    audulus_patch_name = "#{basename}.audulus"
+
+    coordinates = normalize_coordinates(CSV.readlines(path))
+
+    results = { :output_path => audulus_patch_name,
+                :coordinates => coordinates }
+  end
+
+  def self.normalize_coordinates(coordinates)
+    floats = coordinates.map {|strings| strings.map(&:to_f)}
+    sorted = floats.sort_by(&:first)
+    min_x = sorted.map(&:first).min
+    max_x = sorted.map(&:first).max
+    min_y = sorted.map(&:last).min
+    max_y = sorted.map(&:last).max
+
+    sorted.map {|x, y|
+      [(x - min_x)/(max_x - min_x),
+       (y - min_y)/(max_y - min_y)]
+    }
+  end
+
+  def self.parse_arguments!(argv)
+    results = {
+      :spline_only => false
+    }
+    option_parser = OptionParser.new do |opts|
+      opts.banner = "#{$0} [OPTIONS] INPUT_FILE"
+
+      opts.on("-h", "--help", "Prints this help") do
+        results[:help] = opts.help
+      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_build_wavetable_node(argv)
+    options = parse_arguments!(argv)
+    handle_base_options(options)
+
+    patch_data = build_patch_data_from_wav_file(options[:input_filename], options[:title], options[:subtitle])
+    WavetablePatch.build_patch(patch_data)
+  end
+
+  def self.parse_midi_arguments!(argv)
+    results = {}
+
+    option_parser = OptionParser.new do |opts|
+      opts.banner = "#{$0} [OPTIONS] INPUT_FILE"
+
+      opts.on("-h", "--help", "Prints this help") do
+        results[:help] = opts.help
+      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_build_midi_node(argv)
+    options = parse_midi_arguments!(argv)
+    handle_base_options(options)
+    MidiPatch.build_patch(options[:input_filename])
+  end
+
+  def self.parse_spline_arguments!(argv)
+    results = {}
+
+    option_parser = OptionParser.new do |opts|
+      opts.banner = "#{$0} [OPTIONS] INPUT_FILE"
+
+      opts.on("-h", "--help", "Prints this help") do
+        results[:help] = opts.help
+      end
+
+      opts.on("-c", "--csv", "Interpret the input file as CSV, not WAV") do
+        results[:csv] = 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 self.run_build_spline_node(argv)
+    options = parse_spline_arguments!(argv)
+    handle_base_options(options)
+    if options[:csv]
+      patch_data = build_patch_data_from_csv_file(options[:input_filename])
+    else
+      patch_data = build_patch_data_from_wav_file(options[:input_filename])
+    end
+    SplinePatch.build_patch(patch_data)
+  end
+
+  def self.handle_base_options(options)
+    if options.has_key?(:help)
+      puts options[:help]
+      exit(0)
+    end
+
+    path = options[:input_filename]
+    unless File.exist?(path)
+      puts "Cannot find file at #{path}"
+      exit(1)
+    end
+
+    options
+  end
+end

data/lib/midi_patch.rb

@@ -0,0 +1,118 @@
+require 'midilib'
+require_relative 'audulus'
+require_relative 'spline_helper'
+require 'pry'
+
+module MidiPatch
+  STEPWISE_X_DELTA = 0.0001
+
+  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)
+    stepwise_coordinates = make_stepwise(coordinates)
+    SplineHelper.build_spline_node_from_coordinates(stepwise_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
+    }
+
+    stepwise_coordinates = make_stepwise(coordinates)
+    SplineHelper.build_spline_node_from_coordinates(stepwise_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
+
+  def self.make_stepwise(coordinates)
+    last_y = nil
+    coordinates.flat_map {|x, y|
+      result = []
+      result << [x-STEPWISE_X_DELTA, last_y] unless last_y.nil?
+      result << [x, y]
+      last_y = y
+      result
+    }
+  end
+end

data/lib/o2Hz.audulus

@@ -0,0 +1 @@
+{"version":1,"patch":{"id":"866f52fd-60fe-4d50-9b21-47037516ecc0","pan":{"x":0.0,"y":0.0},"zoom":1.0,"nodes":[{"type":"Patch","id":"b466f3bf-8c76-42a4-86f5-ae9690dc48b0","position":{"x":0.0,"y":0.0},"subPatch":{"id":"67324aa6-f27a-41e4-a695-293cfc6c165c","pan":{"x":44.87227,"y":-127.11619},"zoom":1.08962,"nodes":[{"type":"Text","id":"a1b78696-87d6-4619-9982-adf41f919602","position":{"x":-68.38974,"y":186.83118},"exposedPosition":{"x":5.0,"y":-75.0},"text":"o2Hz","width":121.66254},{"type":"Input","id":"fb4e2398-c487-4ab7-ab6d-ca62dab2bdd7","position":{"x":-285.8692,"y":21.53328},"name":"","exposedPosition":{"x":-15.0,"y":-75.0}},{"type":"Output","id":"43cb2b53-8c5b-4d58-8652-22e7a9eab2e3","position":{"x":64.12784,"y":21.37727},"name":"","exposedPosition":{"x":50.0,"y":-75.0}},{"type":"Text","id":"cf932ecc-8d3e-4499-b08a-3d81369f73e3","position":{"x":165.173,"y":44.48822},"exposedPosition":{"x":45.0,"y":-75.0},"text":"Hz","width":256.0},{"type":"Text","id":"81b6f7ed-f744-495f-ad83-7a4ad746f51d","position":{"x":-323.56317,"y":42.14087},"exposedPosition":{"x":-20.0,"y":-75.0},"text":"o","width":256.0},{"type":"Expr","id":"bd81df0d-069d-41bf-996d-853457d7f208","position":{"x":-265.36447,"y":70.76501},"expr":"440"},{"type":"Expr","id":"bee65669-e211-498b-93f8-37c20e9e8001","position":{"x":-169.25708,"y":41.39349},"expr":"exp2(o)*RefHz"}],"wires":[{"from":"bee65669-e211-498b-93f8-37c20e9e8001","output":0,"to":"43cb2b53-8c5b-4d58-8652-22e7a9eab2e3","input":0},{"from":"fb4e2398-c487-4ab7-ab6d-ca62dab2bdd7","output":0,"to":"bee65669-e211-498b-93f8-37c20e9e8001","input":0},{"from":"bd81df0d-069d-41bf-996d-853457d7f208","output":0,"to":"bee65669-e211-498b-93f8-37c20e9e8001","input":1}]}}],"wires":[]}}

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,18 @@
+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']
+    spline_node =
+      if patch_data[:samples]
+        scaled_samples = patch_data[:samples].map {|sample| (sample.to_f + 1.0)/2.0}
+        SplineHelper.build_spline_node_from_samples(scaled_samples)
+      elsif patch_data[:coordinates]
+        SplineHelper.build_spline_node_from_coordinates(patch_data[:coordinates])
+      end
+    Audulus.add_node(patch, spline_node)
+
+    File.write(patch_data[:output_path], JSON.generate(doc))
+  end
+end

data/lib/via.audulus

@@ -0,0 +1 @@
+{"version":1,"patch":{"id":"0e175c84-19b3-4de6-82d6-6e9bee5bceb4","pan":{"x":0.0,"y":0.0},"zoom":1.0,"nodes":[{"type":"Patch","id":"49a0be22-6a99-4381-a45a-ec98e8e68f5a","position":{"x":0.0,"y":0.0},"subPatch":{"id":"ca4bc506-54d0-4131-b83e-e92020914529","pan":{"x":56.28666,"y":48.45356},"zoom":1.7409,"nodes":[{"type":"Input","id":"a5c804e2-53a4-4cf0-af0f-31d9d48edf27","position":{"x":-138.01346,"y":-29.97073},"name":"","exposedPosition":{"x":-25.0,"y":-10.0}},{"type":"Output","id":"296a7cd7-7ea5-423c-996e-4472b890284e","position":{"x":-43.0237,"y":-28.49051},"name":"","exposedPosition":{"x":20.0,"y":-10.0}},{"type":"Text","id":"ee6b6fa7-2be2-41b6-ba01-5f6d7b69cef0","position":{"x":-113.80623,"y":-58.93321},"exposedPosition":{"x":-30.0,"y":-10.0},"text":">","width":256.0},{"type":"Text","id":"ee2f36b6-05f7-423f-939f-3e163257f78d","position":{"x":-22.11625,"y":-53.30904},"exposedPosition":{"x":15.0,"y":-10.0},"text":">","width":256.0}],"wires":[{"from":"a5c804e2-53a4-4cf0-af0f-31d9d48edf27","output":0,"to":"296a7cd7-7ea5-423c-996e-4472b890284e","input":0}]}}],"wires":[]}}

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