music_coder 0.7.0

data/lib/logger.rb

@@ -0,0 +1,39 @@
+# any output to console runs through this
+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)
+  #3 warnings
+  #4 memory updates and debug info
+  attr_accessor :level
+  def initialize
+    self.level = 4
+  end
+  
+  #output something if our level says it's okay
+  def log str, lvl
+    raise "Don't write anything to log level 0." if lvl < 1
+    extra = ""
+    (lvl-1).times {extra+="_"}
+    puts extra + str + extra if level >= lvl
+  end
+  
+  # a loading bar
+  def print_loading_bar(frames_index, len, percent_complete=nil)
+    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}%__")
+    end
+    percent
+  end
+  # puts without newline
+  def print_and_flush(str)
+    print str
+    $stdout.flush
+  end
+
+end

data/lib/math_utils.rb

@@ -0,0 +1,64 @@
+# All generic static math functions needed.
+class MathUtils
+class << self
+end
+# golden ratio
+self::GR = 1.61803398875 unless const_defined?(:GR)
+
+#outputs 0 to 1 increasing by the factor
+#detail:: number of times to apply division. 1 to inf
+#factor:: the number to divide by. 
+def self.division_fade(detail = 8, factor = nil)
+  factor ||= GR
+  raise "Detail must be >= 1" if detail < 1
+  out = Array.new(detail)
+  old = 1
+  out.each_with_index do |x,i| 
+    out[i] = old / factor.to_f
+    out[i] = 1 if i < 1 # first is 1 always
+    old = out[i]
+  end
+  out.reverse
+end
+
+#generates data for sin wave in an array (single cycle)
+#detail:: number of elements in the wave. 
+#default: 2048 very smooth
+def self.sinwave(detail = 2048, saturation=0)
+  raise "Sinwave frames must be specifed as >= 3." if detail < 3
+  val = Array.new(detail)
+  val.each_with_index do |foo,i|
+    progress=i.to_f/detail
+    val[i] = Math.sin(2.0*Math::PI*progress)
+    val[i] = (val[i]-saturation.to_f)+rand*saturation.to_f*2.0
+  end
+  val
+end
+
+#generates wave cycle by duplicating data to fillout the other 3 sections of a wave.
+#data:: data from 0 to 1 for the first section.
+def self.filloutwave(data)
+  val = []
+  i=0
+  while i < data.count
+    val.push data[data.count-i-1] if i > 0
+    i+=1
+  end
+  ret = data + val
+  val = []
+  i=0
+  while i < ret.count
+    val.push -ret[ret.count-1-i] if i > 0
+    i+=1
+  end
+  ret += val
+  ret.pop # remove last 0
+  ret
+end
+require 'matrix'
+FIB_MATRIX ||= Matrix[[1,1],[1,0]]
+#calculate fibonacci number
+def self.fib(n)
+  (FIB_MATRIX**(n-1))[0,0]
+end
+end

data/lib/mixer.rb

@@ -0,0 +1,14 @@
+# 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
+  reduction1 = reduction * 2
+  reduction1 = 0 if reduction1 < 1 
+  reduction1 -= 1 if reduction1 >= 1 
+  f=first * (1.0 - reduction1)
+  s=second * reduction2
+  f+s
+end
+
+end

data/lib/music_coder.rb

@@ -0,0 +1,192 @@
+
+# extend all objects
+class Object
+# initialize all instance vars from a Hash if they are specified in args.
+def init_hash(args)
+  instance_variables.each do |p|
+    v_name = p[1,p.size]
+    arg = args[v_name.to_sym] if not args.nil?
+    self.instance_variable_set p, arg if not arg.nil?
+  end
+end
+
+def deep_copy
+  Marshal.load(Marshal.dump(self))
+end
+def vars_eql?(other,vars=nil)
+  vars ||= instance_variables
+  vars.each do |var|
+    # puts instance_variable_get(var)
+    if instance_variable_get(var).respond_to? 'is_eql'
+      # puts 'responds to is_eql'
+      return false if !(instance_variable_get(var).is_eql other.instance_variable_get(var))
+    else
+      # puts "mine: #{instance_variable_get(var)} other: #{other.instance_variable_get(var)}"
+      return false if !(instance_variable_get(var) == other.instance_variable_get(var))
+    end
+  end
+  true
+end
+end
+
+class Array
+  # add all elements and fit if i'm too small
+  def add_e (array)
+    if !array.nil? && array.count > 0
+      array.count.times do |i|
+        self<<0 if i > self.count-1
+        self[i] += array[i]
+      end
+    end
+    self
+  end
+  # add all elements and fit if i'm too small
+  def add_e_no_resize (array)
+    self.count.times do |i|
+      self[i] += array[i]
+    end
+    self
+  end
+end
+
+#require 'debugger'
+# The top level of the program. This static class contains static methods and static attributes.
+class App
+class << self
+  #file containing input (without .rb extension)
+  attr_accessor :infile
+  #Time of the last output computation
+  attr_accessor :lastgen
+  #write to this to be made
+  attr_accessor :out
+  attr_accessor :start_t
+  attr_accessor :outpath
+  attr_accessor :fileoptions
+  attr_accessor :mixes_num
+  attr_accessor :audio_file_settings
+# how many hits are done, how many are todo
+  attr_accessor :done, :total
+  # perf testing
+  attr_accessor :checks
+  # Logger
+  attr_accessor :logger
+end 
+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'
+end
+
+def self.clear_dir dir_path
+  Dir.foreach(dir_path) {|f| fn = File.join(dir_path, f); File.delete(fn) if f != '.' && f != '..'}
+end
+
+# clears objects ready to write to file.
+def self.clear_ready
+  App.clear_dir "../tmp/"
+  App.out.snddists = []
+  App.out.filelist = FileList.new
+end
+
+# The top level of program calls this
+def self.main_loop
+  puts "Running application code"
+  self.infile = 'input'
+  App.clear_dir App.outpath+"sound/"
+  self.out = AudioOutput.new
+  # App.clear_ready
+  self.out.outfile="#{App.outpath}sound/output.aiff"
+  while true do
+    if generate_new?
+        load_all
+        puts infile + ".rb change detected."
+      begin
+        load '../'+infile+'.rb'
+        files = *(1..App.mixes_num)
+        files.each {|let| 
+          
+          self.out.outfile="#{App.outpath}sound/#{let}#{App::EXT}"
+          puts "+++BEGIN #{let}#{App::EXT} +++"
+          App.start_t = Time.new
+          self.generate
+          
+          }
+      rescue Exception => ex
+        puts "!!! - Mistake in input file!"
+        puts "!!! - " + ex.message
+        puts ex.backtrace.join("\n")
+      end
+      puts "...waiting for input changes..."
+    end
+  sleep(0.8)
+  end
+end
+
+def self.time_since
+  (Time.new - App.start_t)
+end
+
+# Generates audio from input file.
+def self.generate
+  input
+end
+
+# has there been a change in the input file since last generation?
+# file:: the name without .rb extnesion or ./ before it
+# lastgen:: the time of last generation
+def self.generate_new?(file = nil)
+  file = infile if file.nil?
+  now = File.ctime("../"+file+".rb")
+  is_new = (lastgen != now)
+  self.lastgen = now
+  return is_new ? true : false
+end
+
+# To copy ruby classes not pass them by reference
+def self.deep_copy(o)
+  Marshal.load(Marshal.dump(o))
+end
+
+# audio files are read this many frames at a time, reduce to save RAM, but will have longer generating times.
+self.load_all # on load
+# this is the max elements in an array of data for the write file. higher = less CPU load, more RAM 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.outpath = "output/"
+App.start_t = Time.new
+self.mixes_num = 1
+Composer.samplerate = 44100
+Composer.bpm = 128
+App.checks = 0
+self.out = AudioOutput.new
+# make dirs
+require 'fileutils'
+FileUtils.mkdir_p App.outpath+"sound/"
+FileUtils.mkdir_p "tmp/"
+#
+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}
+log "Music Coder", 1
+end

data/lib/snd_dist.rb

@@ -0,0 +1,104 @@
+# the distribution of a ToneSeq, or multiple other SndDists
+class SndDist
+  #Array of floats containing the delays for each time a bar played. 0 to 1.
+  attr_accessor :hits
+  #Array of SndDist
+  attr_accessor :snd
+  #Array of ToneSeq
+  attr_accessor :tss
+  attr_accessor :len
+
+  def initialize
+    @hits = []
+    @snd = []
+    @tss = []
+    @len = 0
+  end
+  
+  def get_children
+    @snd
+  end
+
+# get pointer to the first end node.
+def end_node
+  if !tss.empty?
+    return self
+  else
+    return snd.first.end_node
+  end
+end
+
+# me and all children. not frames, hits
+  def tally_frames(old=0)
+    if !tss.empty?
+      # puts "returning hits count #{hits.count}"
+      return hits.count
+    else
+      result=0
+      snd.each do |sn|
+        result += hits.count*sn.tally_frames(old)
+      end
+      # puts "all in result #{result}"
+      return result
+    end
+  end
+
+  def add sn
+    self.snd<<sn
+  end
+
+  #recursivly create children with 4 hits, or a toneseq with 1 tonepart
+  def populate(depth=0)
+    raise "Error, you ran Dist.populate before seting hits and length first." if hits.count.to_f < 1 || len < 1
+    puts "==|Dep: #{depth}| populating distributed sounds "
+    max_child_len=(len/hits.count.to_f).round
+    if depth==0
+      t=ToneSeq.new
+      self.tss<<t
+      t.make(1,max_child_len)
+    else#not 0 yet, recurse
+      sn=SndDist.new
+      add sn
+      sn.len = max_child_len
+      sn.disperse_hits(4)
+      sn.populate depth-1
+    end
+  end
+
+  # write children
+  def render(parent_hit_index=0)
+    # parent_into = (parent_hit_index+1) / hits.count.to_f #DEP
+    # puts "==#{parent_hit_index} rendering sound #{hits.count} times. (#{App.time_since} secs)"
+    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
+      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} 
+      App.done += 1 if !tss.empty?
+      App.logger.print_loading_bar(App.done, App.total)
+    end
+    files.child_len = (len)
+    files
+  end
+#dep
+  #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 disperse_hits(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
+  end 
+end

data/lib/tests.rb

@@ -0,0 +1,168 @@
+require "./app.rb"
+require "test/unit"
+
+class TestHitSq < Test::Unit::TestCase
+  def setup
+    @h=[0.2,0.3,0.4].HitSq
+    @h2=[0,1].HitSq
+  end
+  def test_loaded
+    assert_equal(3, @h.count)
+    assert_equal(true, @h2.hits.eql?([0.0,1.0]))
+  end
+  def test_bounds
+    assert_raise(RuntimeError) {[1.1].HitSq}
+    assert_raise(RuntimeError) {[-0.1].HitSq}
+    assert_raise(RuntimeError) {@h2<<8}
+  end
+
+  def test_ops
+    @h<<1
+    assert_equal(4, @h.count)
+    @h<<@h2
+    assert_equal(5, @h.count)
+    # without the duplicate now
+    @h>>1
+    assert_equal(4, @h.count)
+    
+    #
+    assert_equal(2, @h2.count)
+    @h2>>1.0
+    assert_equal(1, @h2.count)
+    # Not chaged
+    assert_equal(4, @h.count)
+  end
+  
+  def test_hits_move
+    assert_equal(([0.2,0.3,0.4]), @h.hits)
+    @h.move(0.1)
+    assert_equal(([0.3,0.4,0.5]), @h.hits)
+  end
+end
+
+class TestDists < Test::Unit::TestCase
+  def setup
+    @d=Dist.new
+    @d2=Dist.new
+    @d3=Dist.new
+    @d3.length = bar
+  end
+ 
+  def test_add_dist
+    assert_equal(0, @d.branches)
+    @d<<@d2
+    assert_equal(1, @d.branches)
+    d=0.0.Dist
+    assert_equal([0.0], d.hits.hits)
+  end
+
+  def test_del_dist
+    assert_equal(0, @d.branches)
+    @d<<@d2
+    @d>>@d2
+    assert_equal(0, @d.branches)
+  end
+ 
+  def test_add_dist_arr
+    assert_equal(0, @d.branches)
+    @d<<[@d3,@d2]
+    assert_equal(2, @d.branches)
+  end
+  
+  def test_del_dist_arr
+    assert_equal(0, @d.branches)
+    @d<<[@d3,@d2]
+    assert_equal(2, @d.branches)
+    @d>>[@d3,@d2]
+    assert_equal(0, @d.branches)
+  end
+  
+  def test_persistence
+    assert_equal(0, @d2.hits.count)
+    @d2<<1
+    assert_equal(1, @d2.hits.count)
+    @d2<<[0.7,0.8]
+    assert_equal(3, @d2.hits.count)
+    h=@d2.hits
+    h<<0.1
+    assert_equal(4, @d2.hits.count)
+    h<<0.2
+    assert_equal(5, @d2.hits.count)
+    h>>0.2
+    assert_equal(4, @d2.hits.count)
+    @d2>>[0.1,0.8]
+    # still persists
+    assert_equal(2, @d2.hits.count)
+  end
+  
+  def test_children
+    @d2<<1
+    @d<<[@d2]
+    assert_equal(1, @d.branches)
+    assert_equal(1, @d[0].hits.count)
+    # can't have a snd
+    assert_raise(RuntimeError) {@d<<Snd.new}
+    assert_raise(RuntimeError) {@d.snd}
+    @d>>[@d2]
+    assert_raise(RuntimeError) {@d[0].hits.count}
+  end
+  
+  def test_snd
+    assert_equal(0, @d.sounds)
+    @d<<Snd.new
+    assert_equal(1, @d.sounds)
+  end
+  
+  def test_len
+    d=10.Dist
+    assert_equal(10, d.length)
+    d.length = 100
+    assert_equal(100, d.length)
+  end
+  
+  def test_snddefs
+    s=20.Snd
+    assert_equal(20, s.t.tones.start.freq.start)
+  end
+  
+  def test_def_hits
+    d=Dist.new
+    assert_equal(0, d.hits.count)
+    assert_equal([0.0], d.dist.hits) #default
+  end
+  
+  def test_def_tone
+    d=10.Dist
+    d.make_sound
+    assert_equal(10, d.snd.t.max_frames)
+  end
+  
+  def test_snd_f_def
+    s=20.0.Snd
+    assert_equal(20, s.t.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)
+    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
+  end
+  def test_snd_len_def
+    snd = 155.Snd
+    @d3<<snd
+    assert_equal(bar, snd.t.tones.start.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)
+    snd = Note.new("c#",5)
+    assert_equal(4, snd.note)
+  end
+end