music_coder 0.7.0

data/lib/audio.rb

@@ -0,0 +1,48 @@
+# All disc operations. 
+class App
+
+  def App.open_w_audiofile file
+    raise "no file name to open for writting. " if file.nil? || App.fileoptions.nil?
+#    puts "#{file} #{App.fileoptions}"
+    Sndfile::File.open(file, App.fileoptions)
+  end
+  def self.m_from_array data
+    write_matrix = GSLng::Matrix.from_array(data)
+    write_matrix.transpose
+  end
+
+  def App.write_to_audiofile fout, array
+    fout.write App.m_from_array array
+    GC.start
+  end
+
+  def App.open_write(filen)
+    File.open(filen, 'w')
+  end
+
+  def App.close_write(fi)
+    fi.close
+  end
+
+  def App.split_array(array, size)
+    upto=0
+    ammont=array.count
+    jump=size
+    out = []
+    while upto < ammont do 
+      # puts "upto #{upto} amount #{ammont}"
+      jump = ammont - upto if upto+jump >= ammont
+      # puts "array range #{upto} to #{upto+jump-1}"
+      out << array[upto..upto+jump-1]
+      upto+=jump
+    end
+    out
+  end
+  def App.read_chunk_of(array, start=0, chunk_size)
+    array[start..start+chunk_size-1]
+  end
+
+
+end
+
+require 'sndfile'

data/lib/audio_output.rb

@@ -0,0 +1,110 @@
+class AudioOutput
+  # add all other fls to this
+  attr_accessor :filelist
+  #this didn't need to be an array, but maybe use it for track mixing?
+  attr_accessor :snddists
+  attr_accessor :outfile
+  # of file write
+  attr_accessor :percent_complete
+
+  def initialize()
+      @snddists = []
+      @outfile = nil
+      @filelist= FileList.new
+      @percent_complete = 0
+  end
+  def render
+    log "phase 1 of 2: render sounds", 2
+    App.done=0
+    App.total=0
+    snddists.each {|snddist| App.total+=snddist.tally_frames}
+#    puts "App.total #{App.total}" # Only for progress bar
+    snddists.each {|snddist| self.filelist.addlist snddist.render }
+    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
+    frames_index = 0
+    len = 0 
+    # get max len
+    snddists.each { |sn| len = sn.len if sn.len > len }
+    len = len.round
+    fout = App.open_w_audiofile outfile
+    App.checks = 0 # for performance testing
+    last_jump=0
+    while frames_index < len
+      
+      if frames_index + App::CHUNK_SIZE >= len
+        # set jump to finish it off since it's under chunk size
+        rest = len - frames_index #1 min, chunk_size max.
+        jump = rest
+        log "capping chunk size at #{jump}", 4
+      else
+        jump=App::CHUNK_SIZE
+      end
+
+      values_for_write = []
+#      while values_for_write.count < jump
+      # if frames_index-last_jump >= jump
+      #   puts "frames index was #{frames_index} jump was #{jump}"
+      #   puts "jump neeeds to be > #{frames_index-last_jump}"
+      #   jump = App::CHUNK_SIZE
+      # end
+
+      # jump=frames_index+10000
+
+      while frames_index-last_jump < jump
+        # minimize if too big
+        if frames_index-last_jump+jump > len
+          jump = len-frames_index-last_jump
+          log "minimizing this chunk to #{jump}", 4          
+        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
+        # end
+        # puts "CHUNK recieved #{values.count} "
+#        puts "--> read #{values.join(', ')}"
+        values_for_write+= values
+#        puts "____#{found_vals}"
+#        values.add_e found_vals
+        # 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)
+        self.percent_complete = ((frames_index.to_f/len)*100)
+        # values=nil
+        # GC.start
+      end
+      last_jump=frames_index
+      # puts "--> to write: #{values_for_write.count} #{frames_index} #{len}"
+      App.write_to_audiofile fout, values_for_write if values_for_write.count>0
+      # values_for_write=nil
+      # GC.start
+    end
+    App.close_write fout
+    log "performed #{App.checks} lookup checks.", 4
+    print_tail_info len
+  end
+  def write_text_files file=nil
+    file = App.outpath + "save.rb" if file.nil?
+    log "state save to file #{file}", 2
+    File.open(file, 'w') do |file|  
+      # snddists.each do |snddist|
+      #   file.puts YAML::dump(snddist)
+      # end
+        file.puts YAML::dump(self)
+    end
+  end
+  def print_tail_info total_frames
+    time_taken = App.time_since
+    log 'wrote file: ' + outfile, 1
+    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
+
+end#class

data/lib/composer.rb

@@ -0,0 +1,164 @@
+# contains the functions a music composer needs.
+# all functions are related to music instead of audio.
+class Composer
+class << self
+  #beats per minute of the track. (Set this first thing in your input file)
+  attr_accessor :bpm
+  #fames per second
+  attr_accessor :samplerate
+end
+def self.chords
+  all = Hash.new
+  #Triads
+  all["maj"] = [4, 7] # major
+  all["min"] = [3, 7] # minor
+  all["aug"] = [4, 8] # augmented
+  all["dim"] = [3, 6] # diminished
+
+  #Seventh chords
+  all["dim7"] = [3, 6, 9] # diminished 7th
+  all["mm7"] = [3, 7, 11] # major minor 7th
+  all["min7"] = [3, 7, 10] # minor 7th
+  all["dom7"] = [4, 7, 10] # dominant 7th
+  all["maj7"] = [4, 7, 11] # major 7th
+  # half diminished
+  # augmented
+  # augmented major
+
+  all["sus4"] = [5, 7]
+  all["sus2"] = [2, 7]
+  all["6"] = [4, 7, 9]
+  all["m13"] = [2, 4, 7, 9, 11]
+  all["9#11"] = [2, 4, 6, 7, 10]
+  all["tonic"] = [6]
+  all
+end
+
+def self.scales
+  all = Hash.new
+  all["major"] = [2,4,5,7,9,11] # 7 total
+  all["minor"] = [2,3,5,7,8,10]
+  all["chromatic"] = *(1..10) #splat
+  #all["ionian"] = [2,4,5,7,9,11]
+  all["dorian"] = [2,3,5,7,9,10]
+  all["phygian"] = [1,3,5,7,8,10]
+  all["lydian"] = [2,4,6,7,9,11]
+  all["mixolydian"] = [2,4,5,7,9,10]
+  #all["aeolian"] = [2,3,5,7,8,10]
+  all["locrian"] = [1,3,5,6,8,10]
+  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)
+def self.get_notes(notes_ar, offset = 0)
+  notes = [0] + notes_ar
+  #offset
+  notes.collect! do |val|
+    if offset >= 0
+      val+offset>11 ? val+offset-12 : val+offset
+    else
+      val+offset<0 ? val+offset+12 : val+offset
+    end
+  end
+  notes
+end
+
+# convert beats to seconds
+# @beat: the beat denominator. ie 4 means 4 beats, .125 means 1 8th beat.
+def self.beat(beats)
+  bps = (self.bpm/60.0)
+  return (beats) * (1.0/bps) * self.samplerate.to_f
+end
+
+#convert a note as a string to midi value
+#note:: range: "A" to "G#". No a flats.
+def self.note_m(note)
+  val=nil
+  note.upcase!
+  case note
+  when 'A'
+    val=0
+  when 'A#'
+    val=1
+  when 'B'
+    val=2
+  when 'C'
+    val=3
+  when 'C#'
+    val=4
+  when 'D'
+    val=5
+  when 'D#'
+    val=6
+  when 'E'
+    val=7
+  when 'F'
+    val=8
+  when 'F#'
+    val=9
+  when 'G'
+    val=10
+  when 'G#'
+    val=11
+  else
+    raise "Unknown note name recieved."
+  end
+  val
+end
+
+end

data/lib/fader.rb

@@ -0,0 +1,37 @@
+# An initial value, a 
+class Fader
+# The initial value.
+attr_accessor :start
+# The final value.
+attr_accessor :final
+# The exponential rate it fades from initial to final.
+# range:: +0
+# 0 is linear.
+# higher than 1 means it reachs the final later than linear.
+# less than 1 means it reachs the final sooner than linear.
+attr_accessor :exp
+def initialize(start=nil,final=nil,exp=0)
+  @start = start
+  @final = final
+  @exp = exp
+end
+# set #final to a percentage of start
+def %(percent)
+  self.final = start.to_f*(percent/100.0)
+end
+# operate on both start and final
+def *(mul=0.5)
+  self.start *= mul
+  self.final *= mul
+end
+# getter
+def exp
+  @exp==0 ? nil : @exp
+end
+def exp_no_nil
+  @exp.nil? ? 0 : @exp
+end
+def is_eql(other)
+  vars_eql?(other)
+end
+end

data/lib/file_list.rb

@@ -0,0 +1,202 @@
+
+# tree
+class FileList
+  # ONLY WITH NO CHILDREN
+  attr_accessor :files
+  attr_accessor :file_content_lens
+  attr_accessor :loaded_file_index
+  attr_accessor :loaded_file_data
+
+  # N CHILDREN
+  attr_accessor :filelists
+  # 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
+  def initialize()
+    @files = []
+    @loaded_file_index = nil
+    @filelists = []
+    @filelist_delays = []
+    @child_len = 0
+    @file_content_lens=[]
+    @loaded_file_data = nil
+    @mark_of_death = false
+  end
+
+  def root_get_value(index,size=1)
+    out=get_value(index,size)
+    if out.count < 1
+      # raise "Error looking up a value at that index. fatal. index #{index}, size #{size}." 
+      out=Array.new(size,0)
+    end
+    out
+  end
+# return the value, index frames into your files. recursive.
+  def get_value(index,size=1)
+#    puts "requested #{size}"
+    out = []
+    
+    if files.empty? # has children
+       out=lookup_children(index,size)
+       # raise "Child filelist failed at index #{index}, size #{size}." if out.count < 1
+    else # no children, just files
+#      puts "looked something up"
+      out = get(index,size)
+#      puts "retrieved #{out.count} frames from object files on disk"
+#      puts "got #{out.count}"
+#      puts "=>> no children, real files found value #{out}"
+    end
+#    puts "valuse  #{out}"
+    out
+  end
+
+  def lookup_child(index,size,i)
+    out=[]
+    fl=filelists[i]
+    App.checks+=1
+    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
+    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}"
+      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
+       if spoof_req_len > 0
+         # 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
+         combo = [] + delay_on_future_chunk + future_chunk
+#             puts combo.count
+         out= combo # with resizing, but will be chunk len anyway.
+       else
+         # Will be handled in future chunks.
+#          out.add_e Array.new(2,0)
+       # puts "not above delay"
+#          puts "c #{delay-index}"
+       end
+    end
+    out
+  end
+
+  def lookup_children(index,size)
+    out = []
+    if filelists.count==0
+        #no file lists, so fill with 0s to len
+        sil_amount = size
+        sil_amount = child_len if child_len < sil_amount && child_len != 0  #limit silence to my length
+        sil_amount
+        out = Array.new(sil_amount-index,0) if sil_amount-index > 0
+        ### puts "set mark of death, returning silence #{sil_amount}, my length: #{child_len}"
+        self.mark_of_death = true
+        return []
+    end
+    filelists.each_with_index do |fl,i|
+      out.add_e lookup_child(index,size,i)
+    end
+    out
+  end
+
+  def get(index, size=1)
+#    out=Array.new(1,0)
+out=[]
+    # not opened yet
+    if loaded_file_index.nil?
+      # App.logger.print_and_flush "|t|"
+      load_from_file(0)
+    end
+
+    #still got data to write in THIS file
+    if current_index_fits_opended_file?(index)
+      out = (read_data_at index, size)
+#      puts "fl-no-child: normal read #{out}"
+
+    #need to load next file (index is higher than current)
+    else 
+      # theres more files to load
+      if files.count > loaded_file_index+1 
+        load_from_file(loaded_file_index+1)
+        out = (read_data_at index, size)
+        # puts "fl-no-child: file #{loaded_file_index} is finished. load next. found val #{out}"
+      else # no more files, index is past
+        self.mark_of_death =true
+#        puts "fl-no-child: marking for dead!!!"
+      end
+    end
+    out
+  end
+
+  #return:: total len of this TrackSection
+  #nil is error
+  def get_content_len
+    child_len.nil? ? file_content_lens.reduce(:+) : child_len
+  end
+
+  def current_index_fits_opended_file?(index) # all that have been opened are tallied
+    index < file_content_lens[0..loaded_file_index].reduce(:+)
+  end
+
+  # returning array of size
+  def read_data_at (index,size=2)
+    lookup=loaded_file_index==0 ? index : index-file_content_lens[0..loaded_file_index-1].reduce(:+)
+    #index - all other lengths, so we get a relative index.
+    rb = loaded_file_data.count-1 # right bound
+#    puts "largest possible  #{rb}, lookup #{lookup}"
+    jump = lookup+size-1
+    jump = rb if jump > rb
+    result=loaded_file_data[lookup..jump]
+#    puts "#{lookup }  #{jump} #{result}"
+#    puts "giving data size #{result.count}"
+    result
+  end
+
+  #index
+  def load_from_file(fi)
+    f=File.new(files[fi], "r")
+    data=f.gets(nil)
+    f.close
+    self.loaded_file_index = fi
+    parse_loaded data
+  end
+
+  def parse_loaded data
+    self.loaded_file_data=Marshal.load(data)
+  end
+
+  def addlist list, delay=0
+    self.filelists.push list
+    self.filelist_delays.push delay.to_i
+  end
+
+  def write(wave_data,delay=0)
+    full=wave_data.dps
+    # 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.file_content_lens.push array.count
+      File.open(self.files.last, 'w') do |fout|  
+        fout.puts Marshal.dump(array)
+      end
+    end
+    # puts "written #{spli.count} tmp files"
+  end
+end