music_coder 0.7.0 → 0.7.1

data/lib/api/api.rb

@@ -3,7 +3,14 @@ class Api
   def initialize
     @parents=[]
   end
-  # Add things to me
+  #Add things to me. This can be applied for many classes. Can handles arrays of excepted types.
+  #object Dist can add Dist to children.
+  #object Dist can add Snd to list of sounds.
+  #object Dist and HitSq can add HitSq to list of hits. 
+  #object Dist and HitSq can add Numbers to list of hits. 
+  #object Snd can repalce ToneSeq.
+  #object Snd can add Snd to repalce its ToneSeq. 
+  #object Snd can add TonePart to add it to its ToneSeq. 
   def << toadd
 #    puts "type: #{toadd.class}"
     case toadd
@@ -48,61 +55,163 @@ class Api
   
 end#class
 
-def load_state
-  f=File.open("../output/text/saved.rb",'r')
+#load program state from a saved file.
+def load_state file=nil
+  file=App.outpath + "save.rb" if file.nil?
+  f=File.open(file,'r')
   content=f.read
   # puts content
   App.out= YAML.load(content)
   f.close
 end
 
-def save_state
-  App.out.write_text_files
+#save program state to a file.
+def save_state file=nil
+  App.out.write_text_files file
 end
 
+#generate the audio data for everything in the queue. see #queue method.
 def render
   App.out.render
 end
 
+#make an audio file based off generated data.
 def make
   App.out.make_audio_file
 end
 
+#return the frames in i beats. used for setting lengths when they are needed in frames.
 def beat i=1
   z=Composer.beat i
   z.to_i
 end
+#return the frames in i bars. used for setting lengths when they are needed in frames.
 def bar i=1
   z=Composer.beat i*4
   z.to_i
 end
 
+# add a Dist to the queue of things to be rendered when you call render. see #render.
 def queue dist
   App.out.snddists<<dist.instance_variable_get(:@dist)
 end
 
-# _rendered files
+#clear already rendered files. 
+#usually you will want to do this at the start of the program or temp files 
+#created from the last use will overlap the current ones when you run #make.
 def clear
   App.clear_ready
 end
 
-def bpm_set val
+#set the beats per minute of all following commands. now helper methods like #beat will be usefull.
+def set_bpm val
   Composer.bpm = val
 end
+#return the current beats per minute.
 def bpm
   Composer.bpm
 end
+#shortcut for #render #save_state #make
 def compute
   render
   save_state
   make
 end
-# send str to be logged.
-# level:: it won't be logged unless Logger.level is at or above this level.
+#send String str to be logged.
+#level:: it won't be logged unless Logger.level is at or above this level.
 def log str, level=3
   App.logger.log str, level
 end
 # set Logger.level. Higher means more logging. 0 is silent.
 def log_level set
   App.logger.level = set
+end
+
+
+#outputs the midi notes of the chord in an array
+#note:: midi value of root note in chord. range: 0 to 11
+#name:: anything from Composer.chords
+def chord_notes(note, name = "dim7")
+  set=[]
+  out=[]
+  all=Composer.chords
+  # handle all selected
+  if name=="all"
+    all.keys.each { |val| out.push chord_notes(note, val) }
+  else #normal
+    set = all[name]
+    raise "Unknown scale name" if set.nil?
+    out = [note] # always root
+    set.each do |val|
+      out.push note+val
+    end
+  end
+
+  out
+end
+
+#return array of notes in the Composer#scale
+#note:: midi value of root note. range: 0 to 11
+#name:: anything from Composer.scales.
+def scale_notes(note=0,is_all=false)
+  set=[]
+  out=[]
+  all=Composer.scales
+  # handle all selected
+  if is_all
+    all.keys.each { |val| out.push scale_notes(val,note) }
+  else #normal
+    set = all[Composer.scale]
+    raise "Unknown scale name" if set.nil?
+    out = [note] # always root
+    # add set to out
+    set.each do |val|
+      out.push note+ val
+    end
+  end
+  out
+end
+
+#return an Array of String of chords that could be the i number chord for notes in the Composer#scale.
+#scale:: anything from Composer.scales.
+def scale_chord(i=0)
+  notes = scale_notes
+  raise "#{i} is out of range for that scale, it only has #{notes.count} notes." if notes[i].nil?
+  Composer.matching_chords(notes[i])
+end
+
+#random scale
+def rand_scale
+  Composer.scales.keys.sample # allow for random.
+end
+
+#return an Array of chords (each chord is an Array of Integer notes) 
+#that fit each note consecutively in Composer#scale. 
+#The chord is randomly sampled from those availiable.
+def get_chords
+  out = []
+  notes = scale_notes
+  notes.count.times do |i|
+    begin
+        chord = scale_chord(i).sample #rand
+      if chord == []
+        out << [notes[i]]
+      else
+        out << chord_notes(notes[i], chord)
+      end
+
+    rescue Exception
+      out << [notes[i]]
+    end
+  end
+  out
+end
+
+#returns how far the given note (Integer) is into the scale.
+def note_index(note)
+   scale_notes.index(note)
+end
+#sets Composer#scale
+def set_scale sc
+   Composer.scale = sc
 end

data/lib/api/dist.rb

@@ -2,6 +2,7 @@
 # of varying lengths, and rate of morphs, played without gaps.
 class Dist < Api 
   attr_accessor :dist
+  # will have a defult hit at 0 if it has a sound and no hits have been made.
   def initialize    
     super
     @dist=SndDist.new
@@ -9,6 +10,12 @@ class Dist < Api
     @hits.add_parent self
     persist_hits
   end
+  
+  #add num TonePart to Snd at i's ToneSeq, with my #length as max.
+  def make(num=1, i=0)
+    snd(i).toneseq.make(num)
+  end
+  
   # delete another Dist
   def del todel
     @dist.snd.delete todel.dist
@@ -30,7 +37,7 @@ class Dist < Api
     persist_hits
     self
   end
-  # get a child
+  # get a Dist child
   def [] i
     child=@dist.get_children[i]
     raise "This Dist has no child at index #{i}. " +
@@ -40,7 +47,23 @@ class Dist < Api
     d.make_hits
     d
   end
-  # count children
+  # get last child
+  def last_born
+    child=@dist.get_children.last
+    d=Dist.new
+    d.dist=child
+    d.make_hits
+    d
+  end
+  # get first child
+  def first_born
+    child=@dist.get_children.first
+    d=Dist.new
+    d.dist=child
+    d.make_hits
+    d
+  end
+  # count children (Dists only)
   def branches
     @dist.get_children.count
   end 
@@ -54,14 +77,28 @@ class Dist < Api
     snd.add_parent self
     new=@dist.tss[i]
     raise "Dist has no sound at index #{i}. It has #{sounds} sounds." if new.nil?
-    snd.snd = new
+    snd<< new
     snd
   end
-  # make a new sound with len
-  def make_sound
+  # getter for Snd. Will persist any changes you make to it.
+  def snd i=0
     snd=Snd.new
-    snd.snd.len = @dist.len
-    self<<snd
+    snd.add_parent self
+    new=@dist.tss[i]
+    raise "Dist has no sound at index #{i}. It has #{sounds} sounds." if new.nil?
+    snd<< new
+    snd
+  end
+  # delete all Snd attached to this Dist
+  def clear_snd
+    @dist.tss = []
+    self
+  end
+  # run on all sounds
+  def snd_each
+    sounds.times {|i|
+      yield(snd i)
+    }
     self
   end
   # count sounds
@@ -82,27 +119,29 @@ class Dist < Api
   end
 
   private  
-  # adds a sound if it's valid to do so
+  # adds a sound if it's valid to do so.
   def validate_snd! val
     raise "This Dist can't have sounds, it has children. " if branches > 0
     @dist.tss << val
     val.toneparts.each {|tp|
 #      puts "RUNNING #{length / val.toneparts.count.to_f}"
-      tp.max_frames = length / val.toneparts.count }
+      tp.max_frames = length / val.toneparts.count 
+      
+      }
   end
   # 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
   end 
-  # Add hits, sounds or other dists to me.
+  # Add hits, sounds or other Dist to me.
   def add_single toadd
     case toadd
     when HitSq, Float, Integer
       @hits << toadd
       persist_hits
     when Snd
-      validate_snd! toadd.snd
+      validate_snd! toadd.toneseq
     when Dist
       validate_dist! toadd.dist
     else
@@ -127,16 +166,17 @@ class Dist < Api
   end
 end
 
-# shortcut e.g. 10.Dist for a dist with length of 10 frames
 class Integer
+  #shortcut to create a Dist with length. e.g. 10.Dist returns a new Dist with length of 10 frames already set.
   def Dist
     h=Dist.new
     h.length = self.to_i
     h
   end
 end
-# shortcut e.g. 0.0.Dist for the most used, a single hit at 0.0
 class Float
+  #shortcut to create a Dist with one hit in its #hits.
+  #e.g. 0.1.Dist returns a new Dist with, a single hit at 0.1.
   def Dist
     h=Dist.new
     h<<self

data/lib/api/hit_sq.rb

@@ -99,7 +99,7 @@ class Array
   end
 end
 class Integer
-  #a shortcut. e.g. 4.eqly_spaced gives you HitSq.new.eqly_spaced(4)
+  #a shortcut. e.g. 4.eqly_spaced gives you HitSq#eqly_spaced(4)
   def eqly_spaced(chance = 1, ignore_first=0, ignore_last=0)
     h=HitSq.new
     possible_hits=self

data/lib/api/note.rb

@@ -14,8 +14,40 @@ class Note
     @octave = octave
   end
   
-  # returns a value up n semitones. (changes octave where necessary)
+  #increment by n notes in the scale set in Composer#scale
+  def inc(n)
+    notes = scale_notes
+    ind = note_index(self.note)
+    semis = 0
+    n.times do
+      ind_old = ind
+      ind += 1
+      if ind >= notes.count
+        diff = 12 - notes[ind_old]
+        ind = 0
+      else
+        diff = notes[ind] - notes[ind_old]
+      end
+      semis += diff
+    end
+    (-1*n).times do
+      ind_old = ind
+      ind -= 1
+      if ind < 0
+        ind=notes.count-1 
+        diff = notes[ind] - 12
+      else
+        diff = notes[ind] - notes[ind_old]
+      end
+      semis += diff
+    end
+    self+semis
+  end
+  
+  #returns a value up some semitones. (changes octave where necessary)
+  #n:: number of semitones, can be pos or neg Integer.
   def +(n = 1)
+    return self-(n*-1) if n < 0
     i=0
     out = deep_copy
     while i < n do
@@ -51,7 +83,7 @@ class Note
     vars_eql? other
   end
 
-  # create a sound based off this note.
+  #return a new Snd with its frequency set to this note.
   def Snd
     s=freq.Snd
     s

data/lib/api/snd.rb

@@ -6,10 +6,15 @@ class Snd < Api
     super
   end
   
+  # return its TonePart.
   def tonepart i=0
-    @snd.tonepart i
+    child = @snd.tonepart i
+    raise "This Snd has no tone at index #{i}. " +
+      "It has #{count} tones." if child.nil?
+    child
   end  
     
+  # return its TonePart at j and thats Tone at i.
   def tone i=0, j=0
     @snd.tonepart(j).tone(i)
   end
@@ -18,26 +23,30 @@ class Snd < Api
     @snd.frames=val
     self
   end
-  def t i=0
-    child = @snd.toneparts[i]
-    raise "This Snd has no tone at index #{i}. " +
-      "It has #{count} tones." if child.nil?
-    child
-  end
+  # get length
+  def length
+    @snd.frames end
   # number of tones
   def count
-    snd.toneparts.count
+    toneseq.toneparts.count
   end
+  #ensure all tones fade out to 0 as the final volume. 
+  #note: re-run after changing amp.
   def fade
-    snd.fade
+    toneseq.fade
+  end
+  #return my ToneSeq
+  def toneseq
+    @snd
   end
-  attr_accessor :snd
   private   
   # Add hits, sounds or other dists to me.
   def add_single toadd
     case toadd
     when Snd
-      @snd = toadd.instance_variable_get(:@snd)
+      @snd = toadd.toneseq
+    when ToneSeq
+      @snd = toadd
     else
       return false
     end
@@ -46,17 +55,20 @@ class Snd < Api
   
 end
 
-class Fixnum
+class Integer
+  #same as Float#Snd.
   def Snd
     a = Snd.new
-    a.t.freq = self
+    a.tonepart.freq = self
     a
   end
 end
 class Float
+  #return a new Snd with its frequency set to the value. 
+  #e.g. 500.4.Snd
   def Snd
     a = Snd.new
-    a.t.freq = self
+    a.tonepart.freq = self
     a
   end
 end

data/lib/composer.rb

@@ -6,6 +6,8 @@ class << self
   attr_accessor :bpm
   #fames per second
   attr_accessor :samplerate
+  #the current scale to be used by many commands that require it. String. def: "major".
+  attr_accessor :scale
 end
 def self.chords
   all = Hash.new
@@ -49,62 +51,8 @@ def self.scales
   all
 end
 
-#outputs the midi notes of the chord in an array
-#note:: midi value of root note in chord. range: 0 to 11
-def self.chord_notes(note, name = "dim7")
-  set=[]
-  out=[]
-  all=chords
-  # handle all selected
-  if name=="all"
-    all.keys.each { |val| out.push chord_notes(note, val) }
-  else #normal
-    set = all[name]
-    raise "Unknown scale name" if set.nil?
-    out = [note] # always root
-    set.each do |val|
-      out.push note+val
-    end
-  end
-
-  out
-end
-
-#outputs the scale name and midi notes in hash
-#note:: midi value of root note. range: 0 to 11
-def self.scale_notes(note, name = "major")
-  set=[]
-  out=[]
-  all=scales
-  # handle all selected
-  if name=="all"
-    all.keys.each { |val| out.push scale_notes(note, val) }
-  else #normal
-    set = all[name]
-    raise "Unknown scale name" if set.nil?
-    out = [note] # always root
-    set.each do |val|
-      out.push note+ val
-    end
-  end
-  out
-end
-
-# return set of chords that fit in the scale 
-def self.matching_chords(scale = "major", offset = 0)
-  all = chords
-  scale_n = [0] + scales[scale]
-  out = []
-  all.each do |chord|
-    name = chord[0]
-    notes=get_notes all[name], offset # lookup chord with name
-    out.push name if (scale_n&notes).sort==notes.sort # if all notes are in scale
-  end
-  out
-end
-
-# return an array of notes from a array of notes with an offset, adding the root note at the start.
-# e.g. ([1,10,2],2) outputs [2,3,0,4] (root note is 2, 10 + 2 becomes 0, 1 + 2 is 3 etc)
+#return an array of notes from a array of notes with an offset, adding the root note at the start.
+#e.g. ([1,10,2],2) outputs [2,3,0,4] (root note is 2, 10 + 2 becomes 0, 1 + 2 is 3 etc)
 def self.get_notes(notes_ar, offset = 0)
   notes = [0] + notes_ar
   #offset
@@ -125,6 +73,19 @@ def self.beat(beats)
   return (beats) * (1.0/bps) * self.samplerate.to_f
 end
 
+#return set of chord names of chords that fit in the scale, offset upward by offset notes.
+def self.matching_chords(offset = 0)
+  all = Composer.chords
+  scale_n = [0] + Composer.scales[scale] # not offset at all
+  out = []
+  all.each do |chord|
+    name = chord[0]
+    notes=Composer.get_notes all[name], offset # lookup chord with name and offset
+    out.push name if (scale_n&notes).sort==notes.sort # if all notes are in scale
+  end
+  out
+end
+
 #convert a note as a string to midi value
 #note:: range: "A" to "G#". No a flats.
 def self.note_m(note)
@@ -160,5 +121,5 @@ def self.note_m(note)
   end
   val
 end
-
+Composer.scale = "major"
 end

data/lib/file_list.rb

@@ -191,7 +191,7 @@ out=[]
     # puts "--> values: #{full.join(', ')}"
     spli=App.split_array(full, App::CHUNK_SIZE)
     spli.each_with_index do |array,i|
-      self.files.push "../tmp/#{object_id}_#{i}"
+      self.files.push "#{App::TMP_DIR}#{object_id}_#{i}"
       self.file_content_lens.push array.count
       File.open(self.files.last, 'w') do |fout|  
         fout.puts Marshal.dump(array)

data/lib/logger.rb

@@ -6,9 +6,10 @@ class Logger
   #2 condensed stats and updative info from a process (loading bars)
   #3 warnings
   #4 memory updates and debug info
+  #5 raw data
   attr_accessor :level
   def initialize
-    self.level = 4
+    self.level = 5
   end
   
   #output something if our level says it's okay

data/lib/music_coder.rb

@@ -1,5 +1,9 @@
-
-# extend all objects
+#These are the main methods in the API to be called from anywhere.
+#Other important API classes to read are:
+#* Dist
+#* Snd
+#* Note
+#* HitSq
 class Object
 # initialize all instance vars from a Hash if they are specified in args.
 def init_hash(args)
@@ -13,6 +17,7 @@ end
 def deep_copy
   Marshal.load(Marshal.dump(self))
 end
+#:nodoc: test if attributes are equal
 def vars_eql?(other,vars=nil)
   vars ||= instance_variables
   vars.each do |var|
@@ -51,6 +56,7 @@ end
 
 #require 'debugger'
 # The top level of the program. This static class contains static methods and static attributes.
+#Gem site: rubygems.org/gems/music_coder
 class App
 class << self
   #file containing input (without .rb extension)
@@ -75,25 +81,25 @@ require 'yaml'
 
 # Reload all files in case of update.
 def self.load_all
-  load 'tone.rb'
-  load 'logger.rb'
-  load 'fader.rb'
-  load 'composer.rb'
-  load 'math_utils.rb'
-  load 'wave.rb'
-  load 'wave_data.rb'
-  load 'mixer.rb'
-  load 'audio_output.rb'
-  load 'tone_part.rb'
-  load 'tone_seq.rb'
-  load 'audio.rb'
-  load 'file_list.rb'
-  load 'snd_dist.rb'
-  load 'api/note.rb'
-  load 'api/api.rb'
-  load 'api/dist.rb'
-  load 'api/hit_sq.rb'
-  load 'api/snd.rb'
+  load File.dirname(__FILE__) + '/tone.rb'
+  load File.dirname(__FILE__) + '/logger.rb'
+  load File.dirname(__FILE__) + '/fader.rb'
+  load File.dirname(__FILE__) + '/composer.rb'
+  load File.dirname(__FILE__) + '/math_utils.rb'
+  load File.dirname(__FILE__) + '/wave.rb'
+  load File.dirname(__FILE__) + '/wave_data.rb'
+  load File.dirname(__FILE__) + '/mixer.rb'
+  load File.dirname(__FILE__) + '/audio_output.rb'
+  load File.dirname(__FILE__) + '/tone_part.rb'
+  load File.dirname(__FILE__) + '/tone_seq.rb'
+  load File.dirname(__FILE__) + '/audio.rb'
+  load File.dirname(__FILE__) + '/file_list.rb'
+  load File.dirname(__FILE__) + '/snd_dist.rb'
+  load File.dirname(__FILE__) + '/api/note.rb'
+  load File.dirname(__FILE__) + '/api/api.rb'
+  load File.dirname(__FILE__) + '/api/dist.rb'
+  load File.dirname(__FILE__) + '/api/hit_sq.rb'
+  load File.dirname(__FILE__) + '/api/snd.rb'
 end
 
 def self.clear_dir dir_path
@@ -102,7 +108,7 @@ end
 
 # clears objects ready to write to file.
 def self.clear_ready
-  App.clear_dir "../tmp/"
+  App.clear_dir App::TMP_DIR
   App.out.snddists = []
   App.out.filelist = FileList.new
 end
@@ -172,6 +178,7 @@ self.load_all # on load
 # 46,000 of these per mb roughly.
 App::CHUNK_SIZE = 110_000 unless const_defined?(:CHUNK_SIZE)
 App::EXT = ".aiff" unless const_defined?(:EXT)
+App::TMP_DIR = "tmp/" unless const_defined?(:TMP_DIR)
 App.outpath = "output/"
 App.start_t = Time.new
 self.mixes_num = 1
@@ -182,11 +189,11 @@ self.out = AudioOutput.new
 # make dirs
 require 'fileutils'
 FileUtils.mkdir_p App.outpath+"sound/"
-FileUtils.mkdir_p "tmp/"
+FileUtils.mkdir_p App::TMP_DIR
 #
 App.clear_dir App.outpath+"sound/"
 self.out.outfile="#{App.outpath}sound/output#{App::EXT}"
 self.logger = Logger.new
-App.fileoptions={:mode => :WRITE, :format => :RAW, :encoding => :PCM_16, :channels => 1, :samplerate => Composer.samplerate}
+App.fileoptions={:mode => :WRITE, :format => :AIFF, :encoding => :PCM_16, :channels => 1, :samplerate => Composer.samplerate}
 log "Music Coder", 1
 end

data/lib/tests.rb

@@ -1,6 +1,33 @@
-require "./app.rb"
+load File.dirname(__FILE__) + "/music_coder.rb"
 require "test/unit"
 
+class TestNotes < Test::Unit::TestCase
+  def test_ops
+    n=Note.new(1,5) + (-3)
+    assert_equal(true, Note.new(10,4).is_eql(n))
+    assert_equal(true, Note.new(3,5).is_eql(n+5))
+  end
+  def test_inc
+    Composer.scale = "major"
+    n=Note.new(0,5)
+    assert_equal([0, 2, 4, 5, 7, 9, 11], scale_notes)
+    b=n.inc 2
+    assert_equal 4, b.note
+    b=n.inc 7
+    assert_equal 0, b.note
+    assert_equal 6, b.octave
+    b=n.inc 0
+    assert_equal 0, b.note
+    assert_equal 5, b.octave
+    b=n.inc -2
+    assert_equal 9, b.note
+    assert_equal 4, b.octave
+    b=n.inc -9
+    assert_equal 9, b.note
+    assert_equal 3, b.octave
+  end
+end
+
 class TestHitSq < Test::Unit::TestCase
   def setup
     @h=[0.2,0.3,0.4].HitSq
@@ -48,6 +75,20 @@ class TestDists < Test::Unit::TestCase
     @d3.length = bar
   end
  
+  def test_dist_child_getters
+     @d << (8.Dist << 0.5 << 300.Snd)
+     @d.last_born.snd.length= 10
+     assert_equal([0.5], @d.last_born.hits.hits)
+     assert_equal(1, @d.last_born.snd.count)
+     # persist?
+     @d.last_born << 0.6
+     assert_equal([0.5,0.6], @d.last_born.hits.hits)
+  end
+  def test_dist_default_hit_0
+    dist = 50_000.Dist
+    assert_equal(1, dist.dist.hits.count)
+    assert_equal(0, dist.hits.count)
+  end
   def test_add_dist
     assert_equal(0, @d.branches)
     @d<<@d2
@@ -122,7 +163,7 @@ class TestDists < Test::Unit::TestCase
   
   def test_snddefs
     s=20.Snd
-    assert_equal(20, s.t.tones.start.freq.start)
+    assert_equal(20, s.tone.freq.start)
   end
   
   def test_def_hits
@@ -131,38 +172,66 @@ class TestDists < Test::Unit::TestCase
     assert_equal([0.0], d.dist.hits) #default
   end
   
-  def test_def_tone
+  def test_def_tone_len
     d=10.Dist
-    d.make_sound
-    assert_equal(10, d.snd.t.max_frames)
+    d<< Snd.new
+    assert_equal(10, d.snd.tonepart.max_frames)
   end
   
   def test_snd_f_def
     s=20.0.Snd
-    assert_equal(20, s.t.freq)
+    assert_equal(20, s.tonepart.freq)
   end
   
   def test_snd_len_dist
     snd = 155.Snd
     snd.length= beat
-    assert_equal(beat, snd.t.tones.start.frames)
-    assert_equal(0, snd.t.max_frames)
+    assert_equal(beat, snd.tone.frames)
+    assert_equal(0, snd.tonepart.max_frames)
     snd.length= 0
     snd.length= beat
     @d3<<snd
-    assert_equal(bar, snd.t.max_frames)
-    assert_equal(beat, snd.t.tones.start.frames) # kept, not 0
+    assert_equal(bar, snd.tonepart.max_frames)
+    assert_equal(beat, snd.tone.frames) # kept, not 0
   end
   def test_snd_len_def
     snd = 155.Snd
     @d3<<snd
-    assert_equal(bar, snd.t.tones.start.frames) # if 0 uses full
+    assert_equal(bar, snd.tone.frames) # if 0 uses full
   end
   def test_notes
     snd = Note.new(0,5).Snd
-    assert_equal(440, snd.t.freq)
-    assert_equal(Note.new(0,5).freq, snd.t.note.freq)
+    assert_equal(440, snd.tonepart.freq)
+    assert_equal(Note.new(0,5).freq, snd.tonepart.note.freq)
     snd = Note.new("c#",5)
     assert_equal(4, snd.note)
   end
+  def test_toneseq_pushing
+    @d3 << Note.new(0,5).Snd
+    @d3.snd.length= beat
+    assert_equal(beat, @d3.snd.tone.frames)
+    @d3.make(1)
+    assert_equal(2, @d3.snd.toneseq.toneparts.count)
+    assert_equal(beat/2, @d3.snd.tone.frames) # made 2, frames should be half
+    @d3.make(2)
+    assert_equal(4, @d3.snd.toneseq.toneparts.count)
+    assert_equal(beat/4, @d3.snd.tone.frames) # made 4, frames should be 1/4
+  end
+  def test_scale
+    Composer.scale = "mixolydian"
+    notes = scale_notes
+    assert_equal(7, notes.count)
+    assert_equal([0,2,4,5,7,9,10], notes)
+    
+    snd = Snd.new
+    snd.length= beat
+    @d3<< snd
+    @d3.make(6)
+    7.times do |i|
+      newn = Note.new(notes[i], 4)
+      @d3.snd.tonepart(i).note= newn
+    end
+    assert_equal(392, @d3.snd.tonepart(6).freq.round)
+    assert_equal(277, @d3.snd.tonepart(2).freq.round)
+  end
 end

data/lib/tone.rb

@@ -21,6 +21,7 @@ def initialize(args = nil)
   init_hash(args)
 end
 
+# set saturation for both start and end
 def saturation= val
   wave.saturation= val
 end
@@ -57,14 +58,15 @@ def chord(note, name, element)
   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.
+#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
+  log "tone starting with freq #{lfreq}", 4
   lamp = amp.start
   wave_exp = wave.detail.exp
   freq_exp = freq.exp

data/lib/tone_part.rb

@@ -1,11 +1,11 @@
-# two tones that can be faded between
+# one tone or two tones that can be morphed between eachother
 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)
+def initialize(m=0,t1=Tone.new,t2=Tone.new)
   @tones = Fader.new(t1,t2,0)
   @max_frames = m
   self.frames = m
@@ -18,37 +18,52 @@ def tone i=0
   i==1 ? @tones.final : @tones.start
 end
 
+# set #max_frames and frames on each Tone if 0.
 def max_frames= m
   @max_frames = m
   # set if none
-  self.frames = m if @tones.start.frames == 0 && @tones.final.frames == 0
+  is_frames_set = true
+  is_frames_set = false if tone_count == 1 && tone.frames == 0
+  is_frames_set = false if tone_count > 1 && tone(0).frames == 0 && tone(1).frames == 0
+  self.frames = m if !is_frames_set
 end
 
 def frames= val
-  @tones.start.frames = val
-  @tones.final.frames = val
+  tone(0).frames = val
+  tone(1).frames = val
 end
 
 # get main freq
 def freq
-  tones.start.freq.start
+  tone.freq.start
 end
 #get main note
 def note
-  tones.start.note
+  tone.note
 end
 
+#set freq of start and final to val
 def freq= val
-  @tones.start.freq.start = val
-  @tones.final.freq.start = val
+  tone(0).freq.start = val
+  tone(1).freq.start = val
 end
 
+#set freq of start and final to Note.freq
+#val:: the note to call freq on
+def note= val
+  tone(0).freq.start = val.freq
+  tone(1).freq.start = val.freq
+end
+
+# multiply all amplitudes (Tone.amp) by factor.
 def amp_mult(factor)
-  tones.start.amp.start *= factor
+  tone(0).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
+  tone(0).amp.final *= factor
+  if tone_count > 1
+    tone(1).amp.start *= factor
+    tone(1).amp.final *= factor
+  end
 end
 
 

data/lib/tone_seq.rb

@@ -6,9 +6,16 @@ class ToneSeq
     @toneparts = []
     make(1)
   end
+  #return the total frames of all toneparts combined.
+  def frames
+    total=0
+    toneparts.each {|tp| total+=tp.tone.frames}
+    total
+  end
   def tonepart i=0
     @toneparts[i]
   end
+  #set the frames of each tonepart to val.
   def frames= val
     @toneparts.each {|tp| tp.frames = val}
   end
@@ -19,23 +26,28 @@ class ToneSeq
       }
     self
   end
+  #set length of all toneparts to equally add to set when combined.
   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)
+  #add num TonePart to self, with it's max allowable frames as #frames.
+  def make(num)
   #  puts "ToneSeq: making #{num} parts in tone"
-    num.times { self.toneparts.push TonePart.new((len.to_f/num).round) }
+    num.times { self.toneparts.push TonePart.new }
+    self.len= (frames.to_f).round
   end
 
+  #compile all data on all #toneparts, then write it to file(s)
   def render(parent_hit_index=nil)
-    files=FileList.new
+    data = WaveData.new
     toneparts.each do |tp|
-      files.write tp.out(parent_hit_index).out
+      data + tp.out(parent_hit_index).out
     end
+    files= FileList.new
+    files.write data
     files
   end
 

data/lib/wave.rb

@@ -22,10 +22,10 @@ def saturation= 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.
+#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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: music_coder
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
   prerelease: 
 platform: ruby
 authors: