music_coder 0.7.2 → 0.9.0

data/lib/api/api.rb

@@ -214,4 +214,35 @@ end
 #sets Composer#scale
 def set_scale sc
    Composer.scale = sc
+end
+# the typical series of commands at the start of a simple new music coder file.
+def start
+  log_level 1
+  clear
+  set_bpm 128
+end
+## return first dist in queue
+#def root
+#  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
+  end
+  main
 end

data/lib/api/dist.rb

@@ -8,7 +8,49 @@ class Dist < Api
     @dist=SndDist.new
     @hits=HitSq.new
     @hits.add_parent self
-    persist_hits
+    persist_hits(true)
+  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
+    end
+  end
+  
+  #sets the length of all children Dist to val
+  def set_child_len val
+    branches.times do |i|
+      self[i].length = val
+    end
   end
   
   #add num TonePart to Snd at i's ToneSeq, with my #length as max.
@@ -16,6 +58,10 @@ class Dist < Api
     snd(i).toneseq.make(num)
   end
   
+  #shortcut to create a Mapper, with Mapper#map_to= me
+  def Mapper
+    Mapper.new(self)
+  end
   # delete another Dist
   def del todel
     @dist.snd.delete todel.dist
@@ -106,9 +152,9 @@ class Dist < Api
     @dist.tss.count
   end
   # (internal use only) copy our hits down to the underlining object
-  def persist_hits
+  def persist_hits(is_def = false)
     @dist.hits = hits.hits
-    @dist.hits = [0.0] if hits.hits.count == 0
+    @dist.hits = [0.0] if is_def && hits.hits.count == 0
     self
   end
   protected

data/lib/api/hit_sq.rb

@@ -38,6 +38,66 @@ class HitSq < Api
     end
   end
   public
+  
+  def delete_random chance = 0.5
+    to_del = []
+    hits.each do |h|
+      if rand < chance
+        to_del << h
+      end
+    end
+    to_del.each {|d| self.hits.delete d }
+    persist
+    self
+  end
+  
+  def trim_start portion=0.25
+    save = []
+    hits.count.times do |i|
+      upto = i.to_f / hits.count
+      if upto >= portion
+        save << hits[i]
+      end
+    end
+    self.hits = save
+    persist
+  end
+  
+  def trim_end portion=0.25
+    save = []
+    hits.count.times do |i|
+      upto = i.to_f / hits.count
+      if upto < 1.0 - portion
+        save << hits[i]
+      end
+    end
+    self.hits = save
+    persist
+  end
+  
+  def trim_both portion=0.25
+    save = []
+    hits.count.times do |i|
+      upto = i.to_f / hits.count
+      if upto < 1.0 - portion
+        save << hits[i]
+      end
+    end
+    
+    save2 = []
+    hits.count.times do |i|
+      upto = i.to_f / hits.count
+      if upto >= portion
+        save2 << hits[i]
+      end
+    end
+    self.hits = save&save2
+    persist
+  end
+  #(internal use only)
+  def persist
+    parent.dist.hits = hits if parent
+  end
   #Adds into #hits.
   #possible_hits:: number of hits that can occur. Must be int
   #chance:: chance a hit will be included. range: 0 to 1

data/lib/api/mapper.rb

@@ -0,0 +1,80 @@
+#a mapper is a collection of Dist all as long as a Dist being mapped too,
+#each of these Dist have a child who is getting "mapped" with hits across that length.
+#everything that you need a mapper for can be
+#done without one but it is handy, since it is a common patten.
+class Mapper < Api
+  #the main Dist containing all mappings
+  attr_accessor :dist
+  def initialize(map_to_dist=nil)
+    @dist=Dist.new 
+    @len=0
+    self.map_to= map_to_dist if !map_to_dist.nil?
+  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
+  def mix mixed_ammount = 0.25
+    last_start = 0.0
+    dist.branches.times do |i|
+      self[i].clear_hits
+      self[i] << last_start
+      last_start = last_start + (1.0 - mixed_ammount) * (1.0/dist.branches)
+    end
+  end
+  def count
+    dist.branches
+  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
+    val << dist #add me to him
+  end
+  #get a mapper at i from #dist
+  def [] i=0
+    dist[i]
+  end
+  #return last child
+  def last
+    dist.last_born
+  end
+  #return last #mapee
+  def mapee_last
+    last[0]
+  end
+  #get the child of a mapper (the dist to being mapped) at i
+  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
+    self << len.Dist # bass drum
+    mapee_last.clear_hits
+    mapee_last << 4.eqly_spaced
+    self << len.Dist # snare
+    mapee_last.clear_hits
+    mapee_last << [0.25,0.75]
+    self << len.Dist # hi
+    mapee_last.clear_hits
+    mapee_last << 4.eqly_spaced
+    mapee_last.hits.move(0.125) # offbeats
+    self
+  end
+
+  private
+  # Add Dist to me.
+  def add_single toadd
+    case toadd
+    when Dist
+      dist << @len.Dist
+      dist.last_born << toadd
+    else
+      return false
+    end
+    true
+  end
+end

data/lib/audio_output.rb

@@ -73,7 +73,7 @@ class AudioOutput
         # raise " couldn't find a value... fuck." if found_val.nil?
         # print percent
         frames_index += values.count
-        App.logger.print_loading_bar(frames_index, len, percent_complete)
+        App.logger.print_loading_bar(frames_index, len, percent_complete, 50)
         self.percent_complete = ((frames_index.to_f/len)*100)
         # values=nil
         # GC.start
@@ -100,11 +100,13 @@ class AudioOutput
   end
   def print_tail_info total_frames
     time_taken = App.time_since
-    log 'wrote file: ' + outfile, 1
+    log 'wrote file: ' + outfile, 2
     log 'seconds: ' + (total_frames.to_f / Composer.samplerate).round(2).to_s +
      " (frames: #{(total_frames/1000).round},000)", 2
     log 'time taken: ' + time_taken.round(2).to_s + 
      " seconds (fps: #{(total_frames/time_taken/1000).round()},000)", 2
+    #end the very last line 
+    puts ""
   end
 
 end#class

data/lib/fader.rb

@@ -15,6 +15,10 @@ def initialize(start=nil,final=nil,exp=0)
   @final = final
   @exp = exp
 end
+# randomize the exp with good values.
+def rand_exp
+  self.exp = 0.20 * rand(100)
+end
 # set #final to a percentage of start
 def %(percent)
   self.final = start.to_f*(percent/100.0)

data/lib/logger.rb

@@ -2,8 +2,8 @@
 class Logger
   #higher level means more is logged. 
   #0 means silent. 
-  #1 heading and written files.
-  #2 condensed stats and updative info from a process (loading bars)
+  #1 heading and %.
+  #2 condensed stats and written files
   #3 warnings
   #4 memory updates and debug info
   #5 raw data
@@ -21,13 +21,12 @@ class Logger
   end
   
   # a loading bar
-  def print_loading_bar(frames_index, len, percent_complete=nil)
+  def print_loading_bar(frames_index, len, percent_complete=nil, skipped_percent= 0, max= 100)
     percent = ((frames_index.to_f/len)*100).round(4)
     percent = percent.round if !percent_complete.nil?
-    # puts "percent #{percent}"
-    # puts "fun percent_complete #{percent_complete}"
-    if level > 1 && (percent_complete.nil? || (percent_complete.round < percent))  
-      App.logger.print_and_flush("__#{percent}%__")
+    percent = skipped_percent + (percent.to_f/100.0)*(max-skipped_percent)
+    if level > 0 && (percent_complete.nil? || (percent_complete.round < percent))  
+      App.logger.print_and_flush(" #{percent.round}% ")
     end
     percent
   end

data/lib/mixer.rb

@@ -1,5 +1,7 @@
 # mixes two tracks together or plays one or the other
 class Mixer
+  
+  
 # get volumes at a position
 def self.get(first, second, reduction)
   reduction2 = reduction > 1 ? 1 : reduction

data/lib/music_coder.rb

@@ -100,6 +100,7 @@ def self.load_all
   load File.dirname(__FILE__) + '/api/dist.rb'
   load File.dirname(__FILE__) + '/api/hit_sq.rb'
   load File.dirname(__FILE__) + '/api/snd.rb'
+  load File.dirname(__FILE__) + '/api/mapper.rb'
 end
 
 def self.clear_dir dir_path

data/lib/snd_dist.rb

@@ -80,8 +80,11 @@ end
         files.addlist sn.render(into), delay_in_frames
       end
       tss.each {|sn| files.addlist sn.render(into), delay_in_frames} 
-      App.done += 1 if !tss.empty?
-      App.logger.print_loading_bar(App.done, App.total)
+#      puts "#{ App.done} #{App.total}"
+      if !tss.empty?
+        App.done += 1 
+        App.logger.print_loading_bar(App.done, App.total, nil, 0, 50)
+      end
     end
     files.child_len = (len)
     files

data/lib/tests.rb

@@ -1,6 +1,26 @@
 load File.dirname(__FILE__) + "/music_coder.rb"
 require "test/unit"
 
+class TestTones < Test::Unit::TestCase
+  
+  def test_setters
+    t= Tone.new
+    t.freq.start = (200)
+    assert_equal(200, t.freq.start)
+    t.freq.final = (20)
+    assert_equal(20, t.freq.final)
+    t.set_freq_final (30)
+    assert_equal(30, t.freq.final)
+    t.set_freq_final(20, false)
+    assert_equal(-180, t.freq.final)
+    assert_equal(-180, t.freq_final)
+    assert_equal(20, t.freq_final(false))
+    t.set_freq(250)
+    assert_equal(-230, t.freq_final)
+    t.set_freq(240)
+    assert_equal(-220, t.freq_final)
+  end
+end
 class TestNotes < Test::Unit::TestCase
   def test_ops
     n=Note.new(1,5) + (-3)
@@ -60,6 +80,24 @@ class TestHitSq < Test::Unit::TestCase
     assert_equal(4, @h.count)
   end
   
+  def test_hits_trim
+    h=HitSq.new
+    h.eqly_spaced(8)
+    h.trim_end(0.25)
+    assert_equal(([0.0, 0.125, 0.25, 0.375, 0.5, 0.625]), h.hits)
+    h.trim_start(0.25)
+    assert_equal(([0.25, 0.375, 0.5, 0.625]), h.hits)
+    
+    
+    h.hits = []
+    h << 4.eqly_spaced
+    assert_equal([0.0,0.25,0.5,0.75], h.hits)
+    h.trim_start(0.25)
+    assert_equal([0.25,0.5,0.75], h.hits)
+    h.trim_end(0.34)
+    assert_equal([0.25,0.5], h.hits)
+  end
+  
   def test_hits_move
     assert_equal(([0.2,0.3,0.4]), @h.hits)
     @h.move(0.1)

data/lib/tone.rb

@@ -21,6 +21,88 @@ def initialize(args = nil)
   init_hash(args)
 end
 
+# set frequency #freq#start
+def set_freq (val)
+  dif = freq.start - val
+  freq.start = val
+  set_freq_final freq_final(false) + dif, false
+end
+
+def freq_final(is_relative=true)
+  return is_relative ? freq.final : freq.start + freq.final
+end
+
+# random amp.
+def rand_amp_both(max = 0.8, min = 0.0025)
+  upper = max - min
+  
+  val = rand * upper
+  self.amp.start = min + val
+  val = rand * val # can't be more
+  self.set_amp_final (min + val), false
+  self.amp.rand_exp
+end
+
+# random ammount of detail in a wave. weighted toward lower values weight times.
+def rand_detail_both(min = 3, max = 512, weight=2)
+  upper = max - min
+  
+  val = rand * upper
+  weight.times {val *= rand}
+  self.wave.detail.start= min + val
+  val = rand * upper
+  weight.times {val *= rand}
+  self.wave.detail.final= min + val
+#  puts "start detail #{val}"
+#  puts "final detail #{val}"
+  self.wave.detail.rand_exp
+end
+
+# random ammount of saturation, weighted toward lower values weight times.
+def rand_sat_both weight=2, max=1.0
+  sat = max
+  weight.times {sat *= rand}
+  self.saturations.start= sat
+  
+  sat = max
+  weight.times {sat *= rand}
+  self.saturations.final= sat
+  self.saturations.rand_exp
+#  puts "saturations.start #{saturations.start}"
+#  puts "saturations.final #{saturations.final}"
+#  puts "saturations.x #{saturations.exp}"
+end
+
+# random start frequency in range.
+def rand_freq(min = 12, max = 20_000) 
+  upper = max - min
+  val = min + rand*upper
+  self.freq.start = val
+end
+
+# random frequencies in range.
+def rand_freq_both(min = 12, max = 20_000)  
+  upper = max - min
+
+  rand_freq min, max
+  val = min + rand*upper # final val
+  self.set_freq_final val, false
+  self.freq.rand_exp
+#  puts "freq.start #{freq.start}"
+#  puts "freq.f #{freq.final}"
+#  puts "freq.x #{freq.exp}"
+end
+
+#is_relative:: false for setting it absolute
+def set_freq_final fq, is_relative=true
+  self.freq.final = is_relative ? fq : fq - freq.start
+end
+
+#is_relative:: false for setting it absolute
+def set_amp_final val, is_relative=true
+  self.amp.final = is_relative ? val : val - amp.start
+end
+
 # set saturation for both start and end
 def saturation= val
   wave.saturation= val
@@ -100,12 +182,6 @@ def out
   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

data/lib/tone_part.rb

@@ -1,6 +1,6 @@
-# one tone or two tones that can be morphed between eachother
+# one or two Tone that can be morphed between eachother
 class TonePart
-#Fader
+#Fader of Tone
 attr_accessor :tones
 attr_accessor :max_frames
 attr_accessor :tone_single

data/lib/tone_seq.rb

@@ -2,10 +2,63 @@
 class ToneSeq
   #Array of TonePart
   attr_accessor :toneparts
+  #when joined, a tone sequence makes the end of each tone 
+  #the same as the start of the next one.
+  #this creates a smooth sound.
+  #todo
+  def join
+    toneparts.count.times do |i|
+      # if more after me, do it
+      if i+1 < toneparts.count
+        me = toneparts[i].tone(0)
+        nxt = toneparts[i+1].tone(0)
+        me.detail.final = nxt.detail.start
+        me.saturations.final = nxt.saturations.start
+        me.set_freq_final( nxt.freq.start, false)
+        me.set_amp_final( nxt.amp.start, false)
+        
+        me = toneparts[i].tone(1)
+        nxt = toneparts[i+1].tone(1)
+        me.detail.final = nxt.detail.start
+        me.saturations.final = nxt.saturations.start
+        me.set_freq_final( nxt.freq.start, false)
+        me.set_amp_final( nxt.amp.start, false)
+      end
+    end
+  end
+  
   def initialize()
     @toneparts = []
     make(1)
   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
+    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|
+      # sets the lens randomly.
+      portion = frames_left * rand
+#      puts "portion #{portion}"
+      if i == toneparts.count
+        portion = frames_left
+      end
+      frames_left -= 1+portion
+      toneparts[i].tone.frames = 1+portion if !even
+      #
+      toneparts[i].tone.rand_sat_both 3, max_sat
+      toneparts[i].tone.rand_freq_both(min_f, max_f)
+      toneparts[i].tone.rand_detail_both min_detail
+      max_amp = start_amp
+      if i>0 # it can't be higher than the last amp
+        max_amp = toneparts[i-1].tone.amp.start
+      end
+      toneparts[i].tone.rand_amp_both max_amp, max_amp * 0.75 # not much lower
+    end
+    join
+  end
+  
   #return the total frames of all toneparts combined.
   def frames
     total=0
@@ -50,5 +103,10 @@ class ToneSeq
     files.write data
     files
   end
+  
+  #reduce amp of all tones by this val
+  def amp_reduce val
+    toneparts.each { |tp| tp.amp_mult(1.0/val) }
+  end
 
 end

data/lib/wave.rb

@@ -5,7 +5,7 @@ class Wave
 # 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
+#the ammount of saturation is 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: music_coder
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.9.0
   prerelease: 
 platform: ruby
 authors:
@@ -48,6 +48,7 @@ files:
 - lib/audio.rb
 - lib/fader.rb
 - lib/api/snd.rb
+- lib/api/mapper.rb
 - lib/api/hit_sq.rb
 - lib/api/dist.rb
 - lib/api/api.rb
@@ -79,7 +80,7 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: An application to programmatically create music through code.
+summary: An application to programmatically create music by coding.
 test_files:
 - lib/tests.rb
 has_rdoc: true