music_coder 0.7.0

data/lib/api/api.rb

@@ -0,0 +1,108 @@
+#base class for most of the things the user will touch directly
+class Api
+  def initialize
+    @parents=[]
+  end
+  # Add things to me
+  def << toadd
+#    puts "type: #{toadd.class}"
+    case toadd
+    when Array
+#      puts "recognised array"
+      toadd.each do |ta| 
+        r = add_single ta
+        raise "This type is not recongnised." if r ==false
+      end
+    else
+      r=add_single toadd
+      raise "This type is not recongnised." if r==false
+    end
+    self
+  end
+  # Delete things from me
+  def >> todel
+#    puts "type: #{todel.class}"
+    case todel
+    when Array
+#      puts "deleting array #{todel}"
+      todel.each do |ta| 
+        r = del_single ta
+        raise "This type is not recongnised." if r ==false
+      end
+    else
+      r=del_single todel
+      raise "This type is not recongnised." if r==false
+    end
+    self
+  end
+  
+  def parent index=0
+    @parents[index]
+  end
+  
+  protected
+  def add_parent obj
+    @parents << obj
+    self
+  end
+  
+end#class
+
+def load_state
+  f=File.open("../output/text/saved.rb",'r')
+  content=f.read
+  # puts content
+  App.out= YAML.load(content)
+  f.close
+end
+
+def save_state
+  App.out.write_text_files
+end
+
+def render
+  App.out.render
+end
+
+def make
+  App.out.make_audio_file
+end
+
+def beat i=1
+  z=Composer.beat i
+  z.to_i
+end
+def bar i=1
+  z=Composer.beat i*4
+  z.to_i
+end
+
+def queue dist
+  App.out.snddists<<dist.instance_variable_get(:@dist)
+end
+
+# _rendered files
+def clear
+  App.clear_ready
+end
+
+def bpm_set val
+  Composer.bpm = val
+end
+def bpm
+  Composer.bpm
+end
+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.
+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

data/lib/api/dist.rb

@@ -0,0 +1,145 @@
+# a consecutave sequence of morphable tones (TonePart)
+# of varying lengths, and rate of morphs, played without gaps.
+class Dist < Api 
+  attr_accessor :dist
+  def initialize    
+    super
+    @dist=SndDist.new
+    @hits=HitSq.new
+    @hits.add_parent self
+    persist_hits
+  end
+  # delete another Dist
+  def del todel
+    @dist.snd.delete todel.dist
+    self
+  end
+  # set the total length in frames
+  def length= set
+    @dist.len = set
+    @dist.tss.each {|tss| tss.len = set }
+    self
+  end
+  # get the total length in frames
+  def length
+    @dist.len
+  end
+  # delete all hits
+  def clear_hits
+    @hits.hits = []
+    persist_hits
+    self
+  end
+  # get a child
+  def [] i
+    child=@dist.get_children[i]
+    raise "This Dist has no child at index #{i}. " +
+      "It has #{branches} children." if child.nil?
+    d=Dist.new
+    d.dist=child
+    d.make_hits
+    d
+  end
+  # count children
+  def branches
+    @dist.get_children.count
+  end 
+  # getter for HitSq. Will persist any changes you make to it.
+  def hits
+    @hits
+  end
+  # getter for Snd. Will persist any changes you make to it.
+  def snd i=0
+    snd=Snd.new
+    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
+  end
+  # make a new sound with len
+  def make_sound
+    snd=Snd.new
+    snd.snd.len = @dist.len
+    self<<snd
+    self
+  end
+  # count sounds
+  def sounds
+    @dist.tss.count
+  end
+  # (internal use only) copy our hits down to the underlining object
+  def persist_hits
+    @dist.hits = hits.hits
+    @dist.hits = [0.0] if hits.hits.count == 0
+    self
+  end
+  protected
+  # (internal use only) create our hits from the underlining object
+  def make_hits
+    @hits.hits = @dist.hits
+    self
+  end
+
+  private  
+  # 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 }
+  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.
+  def add_single toadd
+    case toadd
+    when HitSq, Float, Integer
+      @hits << toadd
+      persist_hits
+    when Snd
+      validate_snd! toadd.snd
+    when Dist
+      validate_dist! toadd.dist
+    else
+      return false
+    end
+    true
+  end
+  # Delete hits, sounds or other dists from my lists.
+  def del_single todel
+    case todel
+    when HitSq, Float, Integer
+      @hits >> todel
+      persist_hits
+    when Snd
+      @dist.tss.delete todel.snd
+    when Dist
+      @dist.snd.delete (todel.dist)
+    else
+      return false
+    end
+    true
+  end
+end
+
+# shortcut e.g. 10.Dist for a dist with length of 10 frames
+class Integer
+  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
+  def Dist
+    h=Dist.new
+    h<<self
+    h
+  end
+end

data/lib/api/hit_sq.rb

@@ -0,0 +1,108 @@
+# a pattern of hits to time a Snd
+class HitSq < Api
+  attr_accessor :hits
+  def initialize
+    @hits=[]    
+    super
+  end
+  private   
+  # delete value
+  def del_single todel
+    @hits.delete todel.to_f
+    self
+  end
+  def validate! input
+    val = input.to_f
+    raise "Hit is too high #{input}. Range is 0 to 1." if val > 1.0
+    raise "Hit is too low #{input}. Range is 0 to 1." if val < 0.0
+    
+    #dup?
+    a = hits.dup
+    a << val
+    if a.uniq.length != a.length
+      log "Warning: skipping duplicate hit.", 3
+    else
+      @hits << val
+    end
+    @parents.each {|par| par.persist_hits}
+  end
+  # Add hits.
+  def add_single toadd
+    case toadd
+    when Float, Integer
+      validate! toadd
+    when HitSq
+      toadd.hits.each { |val| validate! val }
+    else
+      false
+    end
+  end
+  public
+  #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
+  #ignore_first:: skip the first n possible hits
+  #ignore_first:: skip the last n possible hits
+  #e.g. disperse_hits(16,1,4,4) makes this pattern [-|-|-|-|+|+|+|+|+|+|+|+|-|-|-|-|]
+  def eqly_spaced(possible_hits = 4, chance = 1, ignore_first=0, ignore_last=0)
+    possible_hits.times do |i|
+      if ignore_first <= i && possible_hits - ignore_last > i
+        delay = i/possible_hits.to_f
+        @hits.push delay if (rand + chance >= 1)
+      end
+    end
+    self
+  end 
+  #return number of hits
+  def count
+    hits.count
+  end
+  # Shift all hits by val, no validation atm
+  def move(val=0.5)
+    self.hits.collect! {|x| 
+      z = (x+val)
+      z = (z*1000).round / 1000.0 # rounding
+      x = z
+    } # delay all
+    self
+  end
+end
+# shortcut e.g. 0.HitSq for the most used, a single hit at 0
+class Integer
+  def HitSq
+    h=HitSq.new
+    h<<self
+    h
+  end
+end
+# shortcut e.g. 0.5.HitSq
+class Float
+  def HitSq
+    h=HitSq.new
+    h<<self
+    h
+  end
+end
+class Array
+  def HitSq
+    h=HitSq.new
+    h<<self
+    h
+  end
+
+  #return a new HitSq. a shortcut for HitSq.new.move(val)
+  def move(val)
+    self.collect! {|x| x=x+val} # delay all
+    h=HitSq.new
+    h<<self
+    h
+  end
+end
+class Integer
+  #a shortcut. e.g. 4.eqly_spaced gives you HitSq.new.eqly_spaced(4)
+  def eqly_spaced(chance = 1, ignore_first=0, ignore_last=0)
+    h=HitSq.new
+    possible_hits=self
+    h.eqly_spaced(possible_hits, chance, ignore_first, ignore_last)
+  end
+end

data/lib/api/note.rb

@@ -0,0 +1,59 @@
+# A musical note. 
+# E.g. A sharp in octave 3.
+class Note
+  # note without octave. from 0 to 11 starting at A ending in G#
+  attr_accessor :note
+  # octave, starts at 0, an 'A' in '5' is 440 hz
+  attr_accessor :octave
+  def initialize(note = 0, octave = 4)
+    if note.class == String
+      @note = Composer.note_m(note)
+    else
+      @note = note
+    end
+    @octave = octave
+  end
+  
+  # returns a value up n semitones. (changes octave where necessary)
+  def +(n = 1)
+    i=0
+    out = deep_copy
+    while i < n do
+      out = Note.new(out.note+1, out.octave)
+      out = Note.new(0, out.octave+1) if out.note==12
+      i+=1
+    end
+    out
+  end
+  # returns a value down n semitones. (changes octave where necessary)
+  def -(n = 1)
+    i=0
+    out = deep_copy
+    while i < n do
+      out = Note.new(out.note-1, out.octave)
+      out = Note.new(11, out.octave-1) if out.note==-1
+      i+=1
+    end
+    out
+  end
+
+  #return the frequency (HZ) of a note.
+  def freq
+    raise "no note or oct given" if (!note || !octave)
+    a=2 ** (octave.to_f-1)
+    b=1.059463 ** note.to_f
+    out = 27.5*a*b
+    return out
+  end
+
+  # return true if this note has the same values as another note.
+  def is_eql(other)
+    vars_eql? other
+  end
+
+  # create a sound based off this note.
+  def Snd
+    s=freq.Snd
+    s
+  end
+end

data/lib/api/snd.rb

@@ -0,0 +1,62 @@
+# a consecutave sequence of morphable tones (TonePart)
+# of varying lengths, and rate of morphs, played without gaps.
+class Snd < Api
+  def initialize
+    @snd=ToneSeq.new
+    super
+  end
+  
+  def tonepart i=0
+    @snd.tonepart i
+  end  
+    
+  def tone i=0, j=0
+    @snd.tonepart(j).tone(i)
+  end
+  # set length
+  def length= val
+    @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
+  # number of tones
+  def count
+    snd.toneparts.count
+  end
+  def fade
+    snd.fade
+  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)
+    else
+      return false
+    end
+    true
+  end
+  
+end
+
+class Fixnum
+  def Snd
+    a = Snd.new
+    a.t.freq = self
+    a
+  end
+end
+class Float
+  def Snd
+    a = Snd.new
+    a.t.freq = self
+    a
+  end
+end