music_coder 0.9.0 → 0.9.1

data/lib/api/api.rb

@@ -226,23 +226,22 @@ end
 #  App.out.snddists[0]
 #end
 
-
-def random_sound root_f = 440, len = beat(1), f_range = 0.2, tone_num = 1+rand(16), parts = 1+rand(3), max_delay = 0.6
-  main = len.Dist
-  tone_num.times do |i|
-    main << len.Dist
-    main.last_born << Snd.new
-    snd = main.last_born.snd
-    snd.length = len.to_f
-    delay = rand*max_delay
-    1.times {delay*=rand}
-    snd.toneseq.random(rand(parts), [true,false].sample, delay, 0.333)
-    snd.tone.set_freq root_f
-    range = root_f * f_range
-    snd.tone.set_freq_final root_f - range/2 + rand*range
-    snd.toneseq.amp_reduce tone_num
-    main.last_born.clear_hits
-    main.last_born << delay
+# return random Integer in range with min and max
+def rand_range max, min=0, weight =1
+  rand_p = max - min
+  weight.times {rand_p *= rand}
+  min + rand_p
+end
+
+
+#the main function. output the code block to numbered files.
+#times:: number of times to run the block into a new file
+def music times=1
+  times.times do |i|
+    clear
+    yield 
+    render
+    App.out.outfile= "#{App.outpath}#{App::OUT_SND_DIR}#{i+1}#{App::EXT}"
+    make
   end
-  main
-end
+end

data/lib/api/dist.rb

@@ -11,41 +11,104 @@ class Dist < Api
     persist_hits(true)
   end
   
+  #return a new Dist with the same hits and length but not children or sounds.
+  def copy
+    out=Dist.new
+    out.length = length
+    out.clear_hits
+    out.hits << hits
+    out
+  end
   
-#make children with the hits you need for a bar of dubstep percussion. set their #length to mine
-#this dist has 5 children, in order: bass drum, secondary bass drum, snare, hi hat, second hi hat
-def dubstep_percussion
-  self << Dist.new # bass drum
-  self.last_born.clear_hits
-  self.last_born << [0.0]
-  self << Dist.new # 2nd bass drum
-  self.last_born.clear_hits
-  self.last_born << [0.75, 0.875] #two last drum hits
-  self << Dist.new # snare
-  self.last_born.clear_hits
-  self.last_born << [0.5] # third beat
-  self << Dist.new # hi hat
-  self.last_born.clear_hits
-  self.last_born << [0.375,0.625] # off beats
-  self << Dist.new # 2nd hi hat
-  self.last_born.clear_hits
-  self.last_born << [0.125,0.875] # off beats
-  set_child_len length
-  self
-end  
-
-  
-  #evenly disperse each child across len by modifying the length and hits. uses #length  
-  def space_children_across
-    len = self.length 
-    branches.times do |i|
-      hit = i.to_f / branches
-      self[i].length = len #(1/branches)* len + hit * len
-      self[i].clear_hits
-      self[i] << hit
+  #add children who have sounds that make a drum like sound
+  #weight:: 0 is lowest drum, 1 is highest
+  def drum weight, amp, f_range=0.0, tone_num = 1, layers=1
+    layers.times do |i|
+      self << Dist.new
+      flay = last_born
+      min_oc = 1
+      max_oc = 5
+      oran = max_oc - min_oc
+      pos_num = scale_notes.count * oran #possible
+      ind = (pos_num * weight).round
+      oct_ind =  min_oc + ind / scale_notes.count
+      log "drum notes #{ind % scale_notes.count} #{oct_ind}, weight #{weight}", 3
+      freq = Note.new(scale_notes[ind % scale_notes.count], oct_ind).freq
+      flay.drumify freq, amp/layers/2, f_range, tone_num #test
+      
     end
+    flay = self[0]
+    self << flay.copy
+    under_sound = last_born
+    under_sound << Snd.new
+    under_sound.snd.length = flay.snd.length
+    under_sound.snd.freq = flay.snd.freq
+    under_sound.snd.amp = amp/2.0
+    under_sound.snd.fade
+    under_sound.snd.tone.amp.exp = flay.snd.tone.amp.exp
+    under_sound.clear_hits # to test
+#     branches.times do |i| 
+#       self[i].snd.amp=0 if i !=branches-1 # to test
+#     end
   end
   
+  #assumes an already existing Snd and HitSq, just makes the Snd more like a percussive instrument
+  def drumify freq, amp, f_range, tone_num
+    random_sound(freq, f_range, tone_num, amp)
+    snd.toneseq.toneparts.last.do_all {|tone| 
+      tone.fade
+      tone.amp.rand_exp true #below linear
+      }
+  end
+  #print hits for debugging
+  def ph
+    puts hits.hits.inspect
+  end
+  
+  #add an Snd to self with some random properties
+  def random_sound root_f, f_range, parts, amp, max_delay = 0.0
+#    tone_num.times do |i|
+      self << Snd.new
+      delay = rand*max_delay
+      1.times {delay*=rand}
+      snd.toneseq.random(rand(parts).to_i, [true,false].sample, delay, amp, root_f+f_range*root_f, root_f-f_range*root_f)
+      snd.toneseq.toneparts.each do |tp|
+#        tp.do_all {|tone| tone.set_freq root_f}
+#        range = root_f * f_range
+#        tp.do_all {|tone| tone.set_freq_final root_f - range/2.0 + rand*range}
+      end
+#      last_born.clear_hits
+#      last_born << delay
+#    end
+  end
+
+  #give mel_layers children each with a unique melody in incrementing octaves.
+  def random_melodies min_b_len, reps, mel_layers = 4, start_octave = 2, max_amp = 0.5, 
+      seqs_max =0, chance = 0.4, random_del_chance = 0.25, max_b_mult=4
+    mel_layers.times do |i|
+      self << Dist.new 
+      melody = last_born
+      map = melody.Mapper
+      map.random_melody min_b_len, reps, start_octave+i, chance, max_amp/mel_layers, rand(seqs_max).to_i, max_b_mult
+      
+      # each layer picks a few bars to delete every note from.
+      to_del = []
+      map.mapee(0).hits.count.times do |h|
+        if rand < random_del_chance
+          to_del << h
+        end
+      end
+#      to_del = [1] #test
+      map.each_dist do |d| 
+        d[0].hits.delete_arr to_del
+#        d[0].ph
+      end
+#      puts to_del
+#      map.dist.branches.times {|j| todel << map[j] if j!=0 }
+#      map.dist >> todel
+    end
+  end
+    
   #sets the length of all children Dist to val
   def set_child_len val
     branches.times do |i|
@@ -62,15 +125,15 @@ end
   def Mapper
     Mapper.new(self)
   end
-  # delete another Dist
-  def del todel
-    @dist.snd.delete todel.dist
+  # delete another Dist at index ind
+  def del ind
+    @dist.snd.delete_at ind
     self
   end
   # set the total length in frames
   def length= set
-    @dist.len = set
-    @dist.tss.each {|tss| tss.len = set }
+    @dist.len = set.round
+#    @dist.tss.each {|tss| tss.len = set }
     self
   end
   # get the total length in frames
@@ -175,7 +238,7 @@ end
       
       }
   end
-  # adds a dist if it's valid to do so
+  # adds a dist if it's valid to do so. 
   def validate_dist! val
     raise "This Dist can't have children, it has sounds. " if sounds > 0
     @dist.add val
@@ -189,6 +252,9 @@ end
     when Snd
       validate_snd! toadd.toneseq
     when Dist
+      if toadd.length == 0 #sets his length to mine if his is 0.
+        toadd.length = length
+      end
       validate_dist! toadd.dist
     else
       return false
@@ -198,13 +264,15 @@ end
   # Delete hits, sounds or other dists from my lists.
   def del_single todel
     case todel
-    when HitSq, Float, Integer
+    when HitSq, Float
       @hits >> todel
       persist_hits
     when Snd
       @dist.tss.delete todel.snd
     when Dist
       @dist.snd.delete (todel.dist)
+    when Integer
+      del todel
     else
       return false
     end

data/lib/api/hit_sq.rb

@@ -5,6 +5,16 @@ class HitSq < Api
     @hits=[]    
     super
   end
+  def delete_arr to_del
+    to_del.each {|di| self.hits.delete_at di }
+    persist
+  end
+  # multiply all hits by mult
+  def * mult
+    hn = []
+    self.hits.collect! {|hit| hit = hit*mult}
+    persist
+  end
   private   
   # delete value
   def del_single todel
@@ -39,6 +49,7 @@ class HitSq < Api
   end
   public
   
+  #chance:: how likely it is a hit will be DELETED
   def delete_random chance = 0.5
     to_del = []
     hits.each do |h|
@@ -113,6 +124,11 @@ class HitSq < Api
     end
     self
   end 
+  
+  def +(val)
+    move val
+    persist
+  end
   #return number of hits
   def count
     hits.count
@@ -121,7 +137,6 @@ class HitSq < Api
   def move(val=0.5)
     self.hits.collect! {|x| 
       z = (x+val)
-      z = (z*1000).round / 1000.0 # rounding
       x = z
     } # delay all
     self
@@ -157,6 +172,7 @@ class Array
     h<<self
     h
   end
+   
 end
 class Integer
   #a shortcut. e.g. 4.eqly_spaced gives you HitSq#eqly_spaced(4)

data/lib/api/mapper.rb

@@ -10,6 +10,224 @@ class Mapper < Api
     @len=0
     self.map_to= map_to_dist if !map_to_dist.nil?
   end
+  #so that no mapees are a Dist, they are only Snd. it flattens the tree of Dist
+  def flatten
+    todel = []
+    count.times do |i|
+      mpe = mapee(i)
+      mpe.branches.times do |j|
+        self << mapee(i).copy
+        mapee_last << mpe[j].snd
+      end
+      todel << mapee(i)
+    end
+    dist >> todel
+  end
+  
+  # trim some hits
+  def reduce_hits
+#    mapee(0).hits.delete_random(0.08) no work
+    mapee(0).hits.trim_both(0.10)
+    mapee(1).hits.trim_both(0.25) if count > 1
+    mapee(2).hits.trim_start(0.34) if count > 2
+  end
+  
+  def random_melody min_b_len, reps =4, oct = 3, chance = 0.75, amp=0.5, seqs=0, max_b_mult = 4
+    self.length = length.to_f / reps
+    random_melody_hits(min_b_len, max_b_mult)
+  #  map.random_melody_hits(beat(1.0).to_f, 0, 1.0) # max len is beat
+    delete_rand_dist 1.0 - chance
+    random_melody_notes(oct,rand(scale_notes.count))
+
+    count.times do |i|
+      freq = mapee(i).snd.tone.freq.start
+      mapee(i).snd.toneseq.random(seqs, true, 0, amp)
+      mapee(i).snd.toneseq.toneparts.each do |tp|
+
+        tp.tone(0).set_freq freq
+        tp.tone(1).set_freq freq
+        tp.tone(0).set_freq_final 0
+        tp.tone(1).set_freq_final 0
+
+#        tp.max_frames = len
+        # rand len
+        extra = 0.5 + rand
+        extra = 1.0 if extra > 1
+        tp.tone(0).frames = tp.tone.frames * extra
+        extra = 0.5 + rand
+        extra = 1.0 if extra > 1
+        tp.tone(1).frames = tp.tone.frames * extra
+     end
+    end
+
+    extend(reps)
+    transfer_hits
+  end
+
+  def random_melody_hits(min_inc, max_inc_mult)
+    upto = 0
+    len = @len
+    while upto < len
+      next_len =(min_inc*(2**(rand(max_inc_mult).to_i))).round# next len
+      if upto + next_len > len # limit to len
+        next_len = len - upto
+      end
+
+      self << next_len.Dist
+      last.clear_hits
+      last << upto.to_f / len
+      upto += next_len #inc
+    end
+  end
+  
+  #call #random_melody_hits first.
+  def random_melody_notes(start_oct = 3, start_note = 0, increments = [1,0,-1])
+    keys = scale_notes()
+    note_index = start_note
+    first_note = Note.new(keys[note_index % keys.count], start_oct)
+    count.times do |i|
+      key = keys[note_index % keys.count]
+      used_note = first_note + note_index
+      mapee(i) << Note.new(key, used_note.octave).Snd
+#      puts Note.new(key, used_note.octave).inspect
+
+      #inc
+      dinc = increments.sample
+      note_index += dinc
+    end
+  end
+  
+  
+  #extend length by mult and repeat all childs hits.
+  def extend mult
+    self.length = @len*mult
+    dist.branches.times do |i|
+      hits = self[i].hits
+      self[i].clear_hits
+      mult.times do |j|
+        new_hits = HitSq.new
+        new_hits << hits
+        new_hits * (1.0/mult)
+        new_hits + (j.to_f / mult)
+        self[i] << new_hits
+      end
+    end
+  end
+  
+  def transfer_hits
+    dist.branches.times do |i|
+#      hits = mapee(i).hits
+#      len = mapee(i).length
+#      
+      mapee(i).clear_hits
+      mapee(i).length = @len
+      mapee(i) << self[i].hits
+      self[i].clear_hits
+      self[i] << 0.0
+#      mapee(i).ph
+    end
+  end
+  
+  def delete_rand_dist chance
+    del = []
+    each_dist do |d|
+      del << d if chance >= rand
+    end
+    del.each {|d| dist >> d}
+  end
+  
+  #if no reps given, will use length to determin it.
+  def fully_extend_all reps=nil
+    dist.branches.times do |i|
+      hits = mapee(i).hits
+      len = mapee(i).length
+      mapee(i).clear_hits
+      reps = (@len.to_f / len).round if reps.nil?
+      mapee(i).length = @len
+      reps.times do |j|
+        new_hits = HitSq.new
+        new_hits << hits
+        new_hits * (1.0/reps)
+        new_hits + (j.to_f / reps)
+#        puts new_hits.hits.inspect
+        mapee(i) << new_hits
+      end
+#      puts mapee(i).hits.hits.inspect
+    end
+  end
+  
+  def do_mapee
+    count.times {|i| yield(mapee(i))}
+  end
+  
+  
+  #make all drum sounds
+  #always will be an extra layer anyway
+  def drum_sounds max_amp=0.5, layers =1
+    tot = count
+    amp = max_amp.to_f / tot #out of total drums
+    tot.times do |i| 
+      this_amp = amp
+      wei = (i+1).to_f/(tot+1)
+#      this_amp = max_amp if wei < 0.4 # if bass-ish
+      range = 0.0
+      seqs= 1
+      if wei > 0.7 # if hihat-ish
+        this_amp /= 3 
+        mapee(i).drum(wei, this_amp, 0.04, 1, layers)
+        mapee(i)[0].snd.toneseq.tonepart(0).do_all {|tone| tone.saturations.start = 0.5 + rand(3).to_f/10}
+        mapee(i)[0].snd.toneseq.do_all{|tp| tp.do_all {|tone|
+            tone.detail = 10000
+            tone.amp.exp = 0.12
+          } }
+      else
+        if wei > 0.35 && wei < 0.65
+          range = 0.5
+          seqs= 2+rand(2)
+        end
+        mapee(i).drum(wei, this_amp, range, seqs, layers)
+      end
+    end
+  end
+  
+  #add dists with the hits you need for a bar of techno percussion.
+  #len:: length of bar
+  #3 children, in order: bass drum, snare, hi hat
+  def techno_percussion len
+    self << len.Dist # bass drum
+    mapee_last.clear_hits
+    mapee_last << 4.eqly_spaced
+    # max len is full, min quarter
+    h_num = mapee_last.hits.count
+    h_num = 1 if h_num == 0
+    mapee_last.length= rand_range(len*0.666/h_num, len*0.11/h_num) 
+
+    self << len.Dist # snare
+    mapee_last.clear_hits
+    mapee_last << [0.25,0.75]
+    h_num = mapee_last.hits.count
+    h_num = 1 if h_num == 0
+    mapee_last.length= rand_range(len/h_num, len/h_num/2) 
+    
+    self << len.Dist # hi
+    mapee_last.clear_hits
+    mapee_last << 4.eqly_spaced
+    mapee_last.hits.move(0.125) # offbeats
+    h_num = mapee_last.hits.count
+     h_num = 1 if h_num == 0
+   mapee_last.length= rand_range(len*0.666/h_num, len*0.666/h_num/2) 
+    
+    self
+  end
+  
+  #evenly disperse each child across length  
+  def fillout
+    count.times do |j|
+      self[j].clear_hits
+      reps = (@len.to_f / (mapee(j).length)).round
+      self[j] << reps.eqly_spaced
+    end
+  end
   #set the right hits to mix all children one after eachother.
   #(this can create a dj mix)
   #mixed_ammount:: the ammount of overlap between children
@@ -24,11 +242,21 @@ class Mapper < Api
   def count
     dist.branches
   end
+  
+  #set length
+  def length= val
+    @len=val.round
+    dist.set_child_len @len
+  end
+  #get length
+  def length
+    @len
+  end
+  
   #length of each child is set to length of val, and we get added to val
   #val:: a Dist
   def map_to= val
-    @len=val.length
-    dist.set_child_len @len
+    self.length= val.length
     val << dist #add me to him
   end
   #get a mapper at i from #dist
@@ -47,24 +275,35 @@ class Mapper < Api
   def mapee i=0
     dist[i][0]
   end
-  
-  #add dists with the hits you need for a bar of techno percussion.
-  #len:: length of bar
-  #3 children, in order: bass drum, snare, hi hat
-  def techno_percussion len
+    
+  #add dist with the hits you need for a bar of dubstep percussion
+  #this dist has 5 children, in order: bass drum, secondary bass drum, snare, hi hat, second hi hat
+  def dubstep_percussion len
     self << len.Dist # bass drum
     mapee_last.clear_hits
-    mapee_last << 4.eqly_spaced
+    mapee_last << [0.0]
+    self << len.Dist # 2nd bass drum
+    mapee_last.clear_hits
+    mapee_last << [0.75, 0.875] #two last drum hits
     self << len.Dist # snare
     mapee_last.clear_hits
-    mapee_last << [0.25,0.75]
-    self << len.Dist # hi
+    mapee_last << [0.5] # third beat
+    self << len.Dist # hi hat
     mapee_last.clear_hits
-    mapee_last << 4.eqly_spaced
-    mapee_last.hits.move(0.125) # offbeats
+    mapee_last << [0.375,0.625] # off beats
+    self << len.Dist # 2nd hi hat
+    mapee_last.clear_hits
+    mapee_last << [0.125,0.875] # offbeats
     self
-  end
+  end  
+
 
+  #pass a block to be run on each dist
+  def each_dist
+    count.times do |i|
+      yield( self[i])
+    end
+  end
   private
   # Add Dist to me.
   def add_single toadd

data/lib/api/snd.rb

@@ -6,6 +6,25 @@ class Snd < Api
     super
   end
   
+  #assumes one tone only
+  def freq= val
+    tone.set_freq val
+  end
+  
+  #freq of first tone only
+  def freq
+    tone.freq.start
+  end
+  
+  def amp= val
+    toneseq.do_all {|tp| 
+      tp.do_all {|tone| 
+        tone.amp.start = val
+        tone.amp.final = 0.0
+        }
+      }
+  end
+  
   # return its TonePart.
   def tonepart i=0
     child = @snd.tonepart i

data/lib/audio_output.rb

@@ -23,7 +23,7 @@ class AudioOutput
     log "phase 1 complete.", 2
   end
   def make_audio_file
-    log "phase 2 of 2: merging all tmp files into #{App::EXT} file. == #{App.time_since}", 2
+    log "phase 2 of 2: merging all tmp files into #{App::EXT} file. secs:#{App.time_since}", 2
     frames_index = 0
     len = 0 
     # get max len
@@ -61,6 +61,7 @@ class AudioOutput
         end
         log "CHUNK_@#{frames_index} asked for #{jump}.  total: #{len}", 4
         values = filelist.root_get_value(frames_index,jump)#, jump)+
+        
         # if values.count==0
         #   puts "VALUES RETURNED 0"
         #   frames_index = len # end this shit

data/lib/fader.rb

@@ -16,8 +16,8 @@ def initialize(start=nil,final=nil,exp=0)
   @exp = exp
 end
 # randomize the exp with good values.
-def rand_exp
-  self.exp = 0.20 * rand(100)
+def rand_exp below_linear =[true,false].sample
+  self.exp = below_linear ? 0.1 + 0.9 * rand : 1+rand(20)
 end
 # set #final to a percentage of start
 def %(percent)

data/lib/file_list.rb

@@ -12,7 +12,7 @@ class FileList
   # delays of children
   attr_accessor :filelist_delays
   # I want each child in the fileslist to fill len frames from my start
-  attr_accessor :child_len, :mark_of_death
+  attr_accessor :child_len, :mark_of_death, :to_del
   def initialize()
     @files = []
     @loaded_file_index = nil
@@ -22,6 +22,7 @@ class FileList
     @file_content_lens=[]
     @loaded_file_data = nil
     @mark_of_death = false
+    @to_del=[]
   end
 
   def root_get_value(index,size=1)
@@ -55,35 +56,41 @@ class FileList
     out=[]
     fl=filelists[i]
     App.checks+=1
-    delay = filelist_delays[i]
+    delay = filelist_delays[i]          
+
     # delay = 0 if delay.nil?
     # puts "deciding if we should go into filelist #{i+1} of #{filelists.count},"+
          # " is #{delay} <= #{index} ? "
 #        puts "child len #{@child_len}"
     needed_until_in = delay - index
+#     puts "needed till in #{needed_until_in}"
     if needed_until_in <= 0
-#          puts "child #{i}"# #{index-delay}"
+      
       if fl.mark_of_death
 #            puts "old count: #{filelists.count}"
         # fl.loaded_file_data=nil
         # GC.start
-        self.filelists.delete_at i
-        self.filelist_delays.delete_at i
-#            puts "#{i} is dead! new count: #{filelists.count}"
+        self.to_del << i
+#        puts "#{i} is dead! new count: #{filelists.count}"
       else
         # normal result
         result =fl.get_value(index-delay,size)
-#             puts "normal #{result.count}"
+        
         out= result
       end
     else 
        spoof_req_len = size - needed_until_in
+#       puts "checking if we can spoof, next move is #{size} and we will be in in #{needed_until_in}."
        if spoof_req_len > 0
+#          puts "checking buggy dude spoofed!! #{index}"
+         
          # Read a smaller chunk in the futre that will be missed if we increment by size.
          index_to_get_in = needed_until_in + index
          delay_on_future_chunk = Array.new(needed_until_in, 0)
          future_chunk = fl.get_value(index_to_get_in-delay, spoof_req_len)
 #             puts future_chunk.count
+
+#          puts "spoofing at #{index} for #{delay} and got #{future_chunk.count} results."
          combo = [] + delay_on_future_chunk + future_chunk
 #             puts combo.count
          out= combo # with resizing, but will be chunk len anyway.
@@ -109,9 +116,14 @@ class FileList
         self.mark_of_death = true
         return []
     end
-    filelists.each_with_index do |fl,i|
+    self.to_del = []
+    filelists.count.times do |i|
       out.add_e lookup_child(index,size,i)
     end
+    self.to_del.each do |i| 
+      self.filelist_delays.delete_at i 
+      self.filelists.delete_at i 
+    end
     out
   end
 

data/lib/math_utils.rb

@@ -4,6 +4,7 @@ class << self
 end
 # golden ratio
 self::GR = 1.61803398875 unless const_defined?(:GR)
+self::GRI = 0.61803398875 unless const_defined?(:GRI)
 
 #outputs 0 to 1 increasing by the factor
 #detail:: number of times to apply division. 1 to inf

data/lib/music_coder.rb

@@ -109,8 +109,12 @@ end
 
 # clears objects ready to write to file.
 def self.clear_ready
-  App.clear_dir App::TMP_DIR
+  App.clear_rendered
   App.out.snddists = []
+end
+
+def self.clear_rendered
+  App.clear_dir App::TMP_DIR
   App.out.filelist = FileList.new
 end
 
@@ -189,6 +193,7 @@ App.checks = 0
 self.out = AudioOutput.new
 # make dirs
 require 'fileutils'
+App::OUT_SND_DIR = 'sound/' unless const_defined?(:OUT_SND_DIR)
 FileUtils.mkdir_p App.outpath+"sound/"
 FileUtils.mkdir_p App::TMP_DIR
 #

data/lib/snd_dist.rb

@@ -72,14 +72,16 @@ end
     files=FileList.new
     raise "forgot to put a length of this sound dist" if len.nil?
     log "Warning: one of your sound distributions have no hits. on purpose? ", 3 if hits.empty?
-    hits.each_with_index do |delay,i|
-      delay_in_frames= (delay*len).round
+    hits.each_with_index do |delay, i|
+      delay_in_frames = (delay *len).round
       into=(i+1).to_f/hits.count
       snd.each do |sn| 
         # puts "another snd dist "
         files.addlist sn.render(into), delay_in_frames
       end
-      tss.each {|sn| files.addlist sn.render(into), delay_in_frames} 
+      tss.each do |sn| 
+        files.addlist sn.render(into), delay_in_frames
+      end
 #      puts "#{ App.done} #{App.total}"
       if !tss.empty?
         App.done += 1 

data/lib/tests.rb

@@ -19,6 +19,10 @@ class TestTones < Test::Unit::TestCase
     assert_equal(-230, t.freq_final)
     t.set_freq(240)
     assert_equal(-220, t.freq_final)
+    t.set_freq_final (0)
+    assert_equal(0, t.freq.final)
+    t.set_freq(10)
+    assert_equal(0, t.freq_final)
   end
 end
 class TestNotes < Test::Unit::TestCase

data/lib/tone.rb

@@ -25,7 +25,7 @@ end
 def set_freq (val)
   dif = freq.start - val
   freq.start = val
-  set_freq_final freq_final(false) + dif, false
+  set_freq_final freq_final(false) + dif, false if freq_final !=0
 end
 
 def freq_final(is_relative=true)
@@ -113,6 +113,10 @@ end
 def detail
   wave.detail
 end
+def detail= val
+  detail.start = val
+  detail.final = val
+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

data/lib/tone_part.rb

@@ -5,12 +5,12 @@ attr_accessor :tones
 attr_accessor :max_frames
 attr_accessor :tone_single
 attr_accessor :tone_count
-def initialize(m=0,t1=Tone.new,t2=Tone.new)
-  @tones = Fader.new(t1,t2,0)
-  @max_frames = m
-  self.frames = m
+def initialize(m=0,t1=Tone.new)
   @tone_count = 1
   @tone_single = t1
+  @tones = Fader.new(t1,nil,0)
+  @max_frames = m
+  self.frames = m
 end
 
 def tone i=0
@@ -18,6 +18,12 @@ def tone i=0
   i==1 ? @tones.final : @tones.start
 end
 
+def two_tones
+  self.tone_count = 2
+  tones.start = tone_single
+  tones.final = tone_single.deep_copy
+end
+
 # set #max_frames and frames on each Tone if 0.
 def max_frames= m
   @max_frames = m
@@ -66,6 +72,12 @@ def amp_mult(factor)
   end
 end
 
+#perform the block on all tones
+def do_all
+  yield (tone(0))
+  yield (tone(1))
+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

data/lib/tone_seq.rb

@@ -32,9 +32,15 @@ class ToneSeq
     make(1)
   end
   
+  def do_all
+    toneparts.each do |tp|
+      yield tp
+    end
+  end
+  
   #random everything
   def random extra_detail = 5, even = false, delay=0, start_amp = 0.5, 
-             max_f = 2000, min_f = 120, max_sat=0.2, min_detail=50
+             max_f = 2000, min_f = 120, max_sat=0.8, min_detail=20
     make(extra_detail) # sets the lens evenly.
     frames_left = self.frames - self.frames.to_f*delay #- extra_detail+1 #minus a little so it must have 1 frame
     toneparts.count.times do |i|
@@ -55,6 +61,13 @@ class ToneSeq
         max_amp = toneparts[i-1].tone.amp.start
       end
       toneparts[i].tone.rand_amp_both max_amp, max_amp * 0.75 # not much lower
+      
+      tp = toneparts[i]
+      tp.two_tones
+      tp.tone(1).rand_sat_both 3, max_sat
+      tp.tone(1).rand_freq_both(min_f, max_f)
+      tp.tone(1).rand_detail_both min_detail
+      
     end
     join
   end
@@ -72,10 +85,11 @@ class ToneSeq
   def frames= val
     @toneparts.each {|tp| tp.frames = val}
   end
+  
   def fade
     @toneparts.each {|tp| 
-      tp.tones.start.fade
-      tp.tones.final.fade
+      tp.tone(0).fade
+      tp.tone(1).fade
       }
     self
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: music_coder
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-08 00:00:00.000000000 Z
+date: 2012-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sndfile
@@ -27,7 +27,15 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.2.0
-description: 
+description: ! "Music Coder is a music programming library. It generates music entirely
+  through code in the chosen programming language (Ruby). \n              There are
+  three main reasons a technically minded person would use Music Coder:\n              Producing
+  music: Write scripts that mimic human creativity, and put some randomness in it,
+  giving you a program that can generate aesthetically pleasing music that is completely
+  unique in each file generated.\n              Scientific exploration: Use the functions
+  in Music Coder to concisely apply algorithms or math to the structure and properties
+  of sound.\n              Making samples: create samples or sections of music that
+  are too complex to be done by hand in graphical audio programs such as Ableton."
 email: karl.is.god@gmail.com
 executables: []
 extensions: []
@@ -80,7 +88,7 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: An application to programmatically create music by coding.
+summary: write programs that create music. music audio library.
 test_files:
 - lib/tests.rb
 has_rdoc: true