music_coder 0.7.0

data/lib/tone.rb

@@ -0,0 +1,136 @@
+# a sound to be played.
+# * a Chord is made of these.
+class Tone
+# duration of the tone in seconds.
+attr_accessor :frames
+# Wave for one single wave in the tone. (Repeated for #frames)
+attr_accessor :wave
+# Fader for amplitude or volume (loudness), 0 to 1. 0 is silent.
+# Fader.final is relative to Fader.start.
+attr_accessor :amp
+# Fader for tone frequency (HZ, cycles/second).
+# Fader.final is relative to Fader.start.
+attr_accessor :freq
+
+# args:: a Hash containing attributes
+def initialize(args = nil)
+  @frames = 0
+  @wave = Wave.new
+  @amp = Fader.new(0.5,0,MathUtils::GR)
+  @freq = Fader.new(220,0,MathUtils::GR)
+  init_hash(args)
+end
+
+def saturation= val
+  wave.saturation= val
+end
+def saturations
+  wave.saturations
+end
+def detail
+  wave.detail
+end
+# returns a buffer with a chord (collection of Tone whos collective amplitude equals
+# the amplitude set in tone) in #wd. one tone on each element
+# name:: String containing the chord name. Range, strings in Composer.chords
+# tone:: Tone settings to use for each tone within the chord. Tone#freq#start
+# will be ignored since we are using the note.
+# element:: Element to save the used tones and notes to.
+def chord(note, name, element)
+  out=Buffer.new
+  chrs=Composer.chord_notes note.note, name
+  notes_total = chrs.count
+  chrs.each_with_index do |v,i|
+    ltone = deep_copy
+    lamp = 1.0/notes_total # lower vol of each tone
+    ltone.amp.start *= lamp # lower vol of each tone
+    ltone.amp.final *= lamp # lower range of vol
+      # use a reduced amplitude. (by tones in chord).
+      # mulitplied by givin amplitude
+    realnote = note+v
+    ltone.note= realnote # set to right freq
+    
+    out.push ltone.out(i,notes_total)
+    element.add_t ltone
+    element.notes.push realnote
+  end
+  out
+end
+
+# output the WaveData for a full tone (chirp). All sound created flows into this atm.
+# freq_exp:: default 0. 0 means linear. higher means it reachs the frequency at the end of it's range later.
+def out
+  # puts "out amp: #{amp.start}"
+  buffer_len = frames
+  inc_x = 0.0
+  data = WaveData.new
+  lfreq = freq.start
+  lamp = amp.start
+  wave_exp = wave.detail.exp
+  freq_exp = freq.exp
+  amp_exp = amp.exp
+  wave_into=0
+  while data.dps.count < buffer_len do
+    wave_data = wave.out(lfreq, lamp, wave_into)
+    data + wave_data
+    inc_x += wave_data.count
+    x = (inc_x.to_f / buffer_len)
+
+    #freq
+    freq_multiplier = x # when exp is off
+    #fade exponentially if on.
+    freq_multiplier = x ** (1.0 /((1.0/freq_exp)*x)) if freq_exp
+    lfreq = freq.start + freq_multiplier*freq.final
+
+    #amp
+    amp_multiplier = x # when exp is off
+    #fade exponentially if on.
+    amp_multiplier = x ** (1.0 /((1.0/amp_exp)*x)) if amp_exp
+    lamp = amp.start + amp_multiplier*amp.final
+
+    #wave
+    wave_into = x # when exp is off
+    #fade exponentially if on.
+    wave_into = x ** (1.0 /((1.0/wave_exp)*x)) if wave_exp
+
+  end
+  data.fit_to buffer_len
+  data
+end
+
+# setting it absolute
+def set_freq_final_no_relative(final)
+  dif=final - freq.start
+  freq.final=dif
+end
+
+# set #freq based off a Note
+def note=(note)
+  freq.start = note.freq
+end
+def note_end=(note)
+  # freq.final = note.freq
+end
+
+# return the note closest to the set frequency
+def note
+  out = Note.new
+  fre = freq.start
+  linear_frequency = Math.log(fre/220.0,2.0) + 4
+  # puts "linear_frequency #{linear_frequency}"
+  out.octave= ( linear_frequency ).floor
+  cents = 1200.0 * (linear_frequency - out.octave)
+  not_wrap = (cents / 99.0)
+  # puts "note no wrap #{not_wrap}"
+  out.note = not_wrap.floor % 12
+  out
+end
+
+# make it end with an amlitute of 0 (complete fade out). 
+def fade
+  amp.final = -amp.start
+  self
+end
+
+
+end

data/lib/tone_part.rb

@@ -0,0 +1,96 @@
+# two tones that can be faded between
+class TonePart
+#Fader
+attr_accessor :tones
+attr_accessor :max_frames
+attr_accessor :tone_single
+attr_accessor :tone_count
+def initialize(m,t1=Tone.new,t2=Tone.new)
+  @tones = Fader.new(t1,t2,0)
+  @max_frames = m
+  self.frames = m
+  @tone_count = 1
+  @tone_single = t1
+end
+
+def tone i=0
+  return tone_single if tone_count == 1
+  i==1 ? @tones.final : @tones.start
+end
+
+def max_frames= m
+  @max_frames = m
+  # set if none
+  self.frames = m if @tones.start.frames == 0 && @tones.final.frames == 0
+end
+
+def frames= val
+  @tones.start.frames = val
+  @tones.final.frames = val
+end
+
+# get main freq
+def freq
+  tones.start.freq.start
+end
+#get main note
+def note
+  tones.start.note
+end
+
+def freq= val
+  @tones.start.freq.start = val
+  @tones.final.freq.start = val
+end
+
+def amp_mult(factor)
+  tones.start.amp.start *= factor
+  #puts "amp: #{tone.tones.start.amp.start}"
+  tones.start.amp.final *= factor
+  tones.final.amp.start *= factor
+  tones.final.amp.final *= factor
+end
+
+
+#return tone with mixed settings of tones#start with tones#final.
+#into:: how much of the final tone is mixed in. 0 is none. Range: 0 to 1
+def out(into)  
+  return tone_single if tone_count == 1
+  
+  out = tones.start.deep_copy
+
+  #wave
+  range = tones.final.wave.detail.start - tones.start.wave.detail.start
+  out.wave.detail.start += range*into
+  range = tones.final.wave.detail.final - tones.start.wave.detail.final
+  out.wave.detail.final += range*into
+  range = tones.final.wave.saturations.start - tones.start.wave.saturations.start
+  out.wave.saturations.start += range*into
+  range = tones.final.wave.saturations.final - tones.start.wave.saturations.final
+  out.wave.saturations.final += range*into
+  
+  #frames
+  range = tones.final.frames - tones.start.frames 
+  out.frames += range*into
+  # puts "frames range #{out.frames}"
+
+  #freq
+  range = tones.final.freq.start - tones.start.freq.start
+  out.freq.start += range*into
+  range = tones.final.freq.final - tones.start.freq.final
+  out.freq.final += range*into
+  range = tones.final.freq.exp_no_nil - tones.start.freq.exp_no_nil
+  out.freq.exp = out.freq.exp_no_nil + range*into
+
+  #amp
+  range = tones.final.amp.start - tones.start.amp.start
+  out.amp.start += range*into
+  range = tones.final.amp.final - tones.start.amp.final
+  out.amp.final += range*into
+  range = tones.final.amp.exp_no_nil - tones.start.amp.exp_no_nil
+  out.amp.exp = out.amp.exp_no_nil + range*into
+
+  out
+end
+
+end

data/lib/tone_seq.rb

@@ -0,0 +1,42 @@
+# a sequence of TonePart that will play sequentially. These are highest level sounds without timing.
+class ToneSeq
+  #Array of TonePart
+  attr_accessor :toneparts
+  def initialize()
+    @toneparts = []
+    make(1)
+  end
+  def tonepart i=0
+    @toneparts[i]
+  end
+  def frames= val
+    @toneparts.each {|tp| tp.frames = val}
+  end
+  def fade
+    @toneparts.each {|tp| 
+      tp.tones.start.fade
+      tp.tones.final.fade
+      }
+    self
+  end
+  def len= set
+    @toneparts.each {|tp|
+      tp.max_frames = set / toneparts.count
+      tp.frames = set / toneparts.count
+    }
+  end
+  # add num TonePart to self, with it's max allowable frames as len.
+  def make(num,len=0)
+  #  puts "ToneSeq: making #{num} parts in tone"
+    num.times { self.toneparts.push TonePart.new((len.to_f/num).round) }
+  end
+
+  def render(parent_hit_index=nil)
+    files=FileList.new
+    toneparts.each do |tp|
+      files.write tp.out(parent_hit_index).out
+    end
+    files
+  end
+
+end

data/lib/wave.rb

@@ -0,0 +1,77 @@
+#a waveform. this is looped to create a Tone.
+class Wave
+# stores the detail amount in a #Fader.start. nil means use sin wave during generation.
+# Fader.start is the main 
+# Fader.final is at the end. nil means same as wave start
+attr_accessor :detail
+#saturation effect (a random fluctuation on each data point to the cycle).
+#degree:: The ammount of saturation. Higher is more, 0 is none. range: 0 to 1
+attr_accessor :saturations
+# hack to dramatically speed it up when on.
+attr_accessor :cache_wave, :old_wave
+
+def initialize(start=512,final=512,exp=0)
+  @detail = Fader.new(start, final, exp)
+  @saturations = Fader.new(0,0,0)
+  @cache_wave=Array.new(2)
+  @old_wave = nil#Wave.new # so false first time with is_eql
+end
+
+def saturation= val
+  saturations.start = val
+  saturations.final = val
+end
+
+# return WaveData of data for a single wave cycle
+# len:: length in frames
+# amp:: amplitude or volume (loudness), 0 to 1. 0 is silent
+# wave_into:: how much of the final wave data is used this time. range: 0 to 1.
+# 
+def out(freq, amp = 1, wave_into = 1)
+  final=WaveData.new
+  start=WaveData.new
+  if is_eql old_wave
+#    puts "using cahce"
+    start = cache_wave[0]
+    final = cache_wave[1]
+  else
+#    puts "not using cahce"
+    self.cache_wave=[nil,nil]
+    self.old_wave=self.dup
+    self.cache_wave[0] =WaveData.new(MathUtils.sinwave(detail.start, saturations.start))
+    self.cache_wave[1] =WaveData.new(MathUtils.sinwave(detail.final, saturations.final))
+    start = cache_wave[0]
+    final = cache_wave[1]
+  end
+
+  data = []
+  len = Composer.samplerate / freq
+  
+  len.to_i.times do |i|
+    progress=i.to_f/len  # from 0 to 1
+    if (detail.start > 0)
+      val = start.interpolate progress
+      # merging two waveforms
+      if (detail.final > 0)
+        val2 = final.interpolate progress
+        val_range = val2-val
+        val = val + val_range*wave_into
+      end
+    else # normal sign wave
+      raise "Error, wave detail isn't > 0"
+      # val = Math.sin(2.0*Math::PI*progress)
+    end
+    # puts "amp #{amp}, val #{val}"
+    val *= amp # reduce volume by this
+    data[i] = val
+  end
+  # puts "--> values: #{data.join(', ')}"
+  result=WaveData.new(data)
+  return result
+end
+
+def is_eql(other)
+  vars_eql?(other, ['@detail','@saturations'])
+end
+
+end

data/lib/wave_data.rb

@@ -0,0 +1,103 @@
+# basically an array of data of a fully rendered down sound.
+class WaveData
+# the data points in an Array of Float. range -1 to 1 unless you like distortion.
+attr_accessor :dps
+# Array containing blanks frames at the start as Integer at [0], end at [1]
+attr_accessor :blanks
+attr_accessor :out_file
+def initialize(dps=Array.new,file=nil)
+    @dps = dps.dup
+    @blanks = [0,0]
+    @out_file=file
+end
+
+#TODO
+def included_blanks
+end
+
+
+#return the datapoints within a range of indexs.
+def get(start, final=nil)
+  final ||= dps.count
+  WaveData.new dps.slice(start..final)
+end
+
+# fit to the size of #dps to len by removing or adding tailing points 
+# fade_frames:: stop the annoying popping at end of sound by fading out this many frames
+def fit_to(len, fade_frames=250)
+  meant_to_be = len
+  self.dps.pop(dps.count- meant_to_be) if meant_to_be < dps.count
+  while meant_to_be > dps.count # too short
+    self.dps.push 0
+  end
+  # stop the annoying popping
+  if dps.count > fade_frames
+    fade_frames.times do |i|
+      dps[dps.count-1-i] *= i.to_f / fade_frames
+    end
+  end
+  self
+end
+
+#duplicate the current data n times.
+def dup(n=1)
+  n.times{dps.concat(dps)}
+  self
+end
+
+#return the value of a wave at the specifed progress 0 to 1
+def interpolate(progress)
+  progress *= dps.count # range from 0 to wavedata length.
+  val = dps[progress.to_i] # truncate progress.
+  #puts progress.to_i
+  # now add the interpolation to the next point
+  if (progress < dps.count-1) # avoid error on last point
+    dif_x = progress.to_i+1 - progress # how far to next datapoint? 0 to 1
+    dif_y = dps[progress.to_i+1] - dps[progress.to_i]
+    interpolation = dif_x * dif_y
+    val += interpolation
+  end
+  return val
+end
+
+# return num of #dps
+def count
+  dps.count
+end
+
+def add(array)
+  self.dps+= array
+  self
+end
+
+#appends Array data to dps
+def +(data)
+  self.dps+= data.dps
+  self
+end
+
+#append silence to #dps. 
+#frames:: duration of the silence in seconds
+#default: one beat.
+#val:: constant middle value in buffer. 
+#default: 0 Range: -1 to 1
+def silence(frames, val = 0)
+  d=WaveData.new(Array.new(frames, val))
+  self+d if frames > 0
+  self
+end
+
+# combine my dps with WaveData wave.
+# adding length if necessary.
+def mix(wave)
+  other = wave.dps
+  longest = dps.count > other.count ? dps : other
+  longest.each_with_index do |a,i|
+    my_v = (dps[i].nil? ? 0 : dps[i])
+    oth_v = (other[i].nil? ? 0 : other[i])
+    dps[i] = my_v + oth_v 
+  end
+  self
+end
+
+end