juicy 0.0.8 → 0.1.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YjQ4MDJlZTZjMTFkOWI5NzJkNTFiN2Y3OWY3YjYwMzdlYmI3NGNkNw==
+    ZmVjZDlhNGNmZDc2MmM0NjQ3NjAxOWE4ZWU0NTAzNjYzMDBhYjE0MA==
   data.tar.gz: !binary |-
-    OTFkMmQ1ZWEwNzM3MTEwMjVlY2EyY2JkYWY4M2M5MjE4OWM2YzAwNA==
+    ZDc4ODNhNzEzZTZiODBlYjRhZjQ3MjU4Y2ZkOGVjNmMyNzVjN2RmMA==
 SHA512:
   metadata.gz: !binary |-
-    MzQ3MmZiOTEyOWQ4M2IzZTUyNTIzMDI3NjUzMjQxYjU5ZTcyNDI4M2ExYjFl
-    N2UxN2FkYjgzNTg4MGJlM2FkOWVmNGIyMThkMzkyYWQ4YjQ1YWFmMjFhZmNm
-    Mzk2YjgyMWExMmM0ZTY0NDM4NTgxZTFiMTQxMGY4OTNiMzY2YzU=
+    OTgwNjBkOTlhZDhiOTYyOTgxNTI5ZjNjMjMyNTdkMDQyY2RhMmNjMTJhOGMz
+    YjE3NmE3ZDQwMzA2YTNhZTFkZTM4YWIzOWEyYjU0NDI0MzM5MWVhNGVjMTg0
+    ZmQ5NDk1YzM5OTU1NjU4NzRmYjZmNzkxNDQ5OWJkNjI2ZDYxMjQ=
   data.tar.gz: !binary |-
-    OGE2ZDNkMDNhMGNmZjYyZjY3OTYzZmJkMzk1ZGQzNGRmM2NhMmE5M2Y0OTkw
-    ZjIyMDQ2NmY5ZjdiMzU0YmE2OGEzNjNkMjEyMjQ3NmJlOTcwYWMwOGYyZTJi
-    YjIxOTM3OGU2OTliYzdlOTRkNWZmNGM1MWJjZTc1MGJhYzdiMGE=
+    YTgyMWY4OTg2M2ZmMzBmMzRkNWQzZmRhZmU1MjMxNzg1MjBlN2MyM2NiZmFi
+    YzBhYjZlNTBlYzMyYzFiMTc3NDhhMjk2NmYyNWY1OGE2ZWRlYmEwMWE2NTNj
+    NWRlOTFkMWUzYmY2MmE3ZGE4NzVhMmEwNGU1YjExZDdlZmM2NWU=

data/bin/juicy.rb

@@ -1,27 +1,65 @@
 require_relative '../lib/juicy.rb'
 include Juicy
+play = false
+# To make a pitch, give it a frequency.
+# By default, the frequency will be tuned to the nearest
+# frequency in equal temperament.
+#
+pitch = Pitch.new(445)
+puts pitch
+pitch.play if play
 
-p = Pitch.new(445)
-puts p
-p.play
+puts "----------"
+# A Note is a Pitch with a name.
+# You give it a note name and an octave
+#
+note = Note.new("G#", -1)
+puts note
+note.play if play
 
-note = Note.new("A")
-#12.times {(n+=1).play}
+puts "----------"
+# You can also add or subtract from a note to go to the next half step
+note += 1
+puts note
+note.play if play
+note -= 2
+puts note
+note.play if play
 
-ch = Chord.new(root: note)
-ch.play
+puts "----------"
+# With this much, you can make your own scales!
+note = Note.new("C")
+major_scale = [2,2,1,2,2,2,1]
+major_scale.each do |step|
+  puts note
+  note.play if play
+  note += step
+end
+puts note
+note.play if play
 
-ch2 = Chord.new(root: note)
-ch2.play
-ch2.play(duration: 500)
+puts "----------"
+# Of course, this is cumbersome to do all on our own,
+# so you have a Scale available to you.
+scale = Scale.new(:major, Note.new("D", -1))
+puts scale
+scale.each_note do |note|
+  note.play if play
+end
+# 
+# ch = Chord.new(root: note)
+# ch.play
+# 
+# ch2 = Chord.new(root: note)
+# ch2.play
+# ch2.play(duration: 500)
 
 # while there is enough here to write out your own scales,
 # current development work is being done on scale objects
 # and a beat sequencer to bring it all together.
 
-intervals = [0,2,2,1,2,2,2,1]
-intervals.each do |interval|
-  (note+=interval).play
-end
-
-puts ch
+scale = Scale.new(:major, Note.new("G", -1))
+puts scale
+scale.each_note do |note|
+  note.play
+end

data/lib/juicy.rb

@@ -1,10 +1,20 @@
-require_relative '../../win32-sound/lib/win32/sound.rb'
+# require 'win32-sound'
+# require_relative 'juicy/win32/sound.rb'
+require_relative 'win32/sound'
+require_relative 'win32/wave_out_play_freq'
 
-require_relative 'juicy/pitch.rb' #toned (or not) frequency in a chosen pitch space (temperament/intonation)
-  require_relative 'juicy/note.rb' #named pitch
-    require_relative 'juicy/chord.rb' #collection of notes
-      require_relative 'juicy/chord_progression.rb' #collection of chords in sequence
-    require_relative 'juicy/scale.rb' #sequence of relative pitch changes ex. chormatic, diatonic, whole-note, pentatonic
-  require_relative 'juicy/mode.rb' #'flavor' of diatonic scale
-  require_relative 'juicy/scale_degree.rb' #index of given scale relative to root/tonic
-  require_relative 'juicy/key.rb' #scale at a given root note, i.e. Juicy::Note
+require_relative 'juicy/pitch' #toned (or not) frequency in a chosen pitch space (temperament/intonation)
+  require_relative 'juicy/note' #named pitch
+  require_relative 'juicy/duration' #length of note in musical time (quarter note, eighth note, etc.)
+    require_relative 'juicy/chord' #collection of notes
+      require_relative 'juicy/chord_progression' #collection of chords in sequence
+      require_relative 'juicy/melody' #collection of chords in sequence
+      
+    require_relative 'juicy/scale' #sequence of relative pitch changes ex. chromatic, diatonic, whole-note, pentatonic
+  require_relative 'juicy/mode' #'flavor' of diatonic scale
+  require_relative 'juicy/scale_degree' #index of given scale relative to root/tonic
+  require_relative 'juicy/key' #scale at a given root note, i.e. Juicy::Note
+  require_relative 'juicy/voice' #an instrument
+  require_relative 'juicy/measure' #a measure of beats
+  require_relative 'juicy/track' #a track of notes
+  require_relative 'juicy/song' #

data/lib/juicy/chord.rb

@@ -10,11 +10,21 @@ module Juicy
       
     }
     
-    def initialize(options = {root: Note.new(:C), quality: :major, inversion: 0, context: :none})
+    attr_reader :duration
+    attr_accessor :sum_of_queued_chord_durations, :how_far_into_the_song_you_are
+    
+    def initialize(options = {root: Note.new(:C), quality: :major, inversion: 0, context: :none, duration: Duration.new("quarter")})
       @root = (options[:root].kind_of?(Note) ? options[:root] : Note.new(options[:root])) || Note.new(:C)
       @quality = options[:quality] || :major
       @inversion = options[:inversion] || 0
       @context = options[:context] || :none
+      @duration = options[:duration] || Duration.new("quarter")
+	    @type = :triad
+      @notes = [@root, @root+2, @root+4]
+    end
+	
+    def to_s
+      "chord type: #{@type}, quality: #{@quality}, root: #{@root}, inversion: #{@inversion}"
     end
     
     def inspect
@@ -35,6 +45,7 @@ module Juicy
         pitches = pitches[1..-1] + [(pitches[0]+12)]
         inversion -= 1
       end
+      
       pitches.each do |interval|
         notes << Note.new(PITCHES.key((PITCHES[@root.name]+interval) % 12))
       end
@@ -103,6 +114,41 @@ module Juicy
     
     alias_method :invert, :cycle
     
+    def prepare(options = {duration: 200, octave: (@octave-Note.default_octave)})
+      @prepared_notes = []
+      @notes.each do |note|
+        options[:duration] = options[:duration] || 200
+        options[:octave] = options[:octave] || (note.octave-Note.default_octave)
+        
+        @prepared_notes << note.prepare(options)
+      end
+    end
+    
+    def play_prepared
+      th = []
+      #puts @prepared_notes.inspect
+      @prepared_notes.each do |note|
+        th << Thread.new {
+          note.play_prepared.join
+          
+          
+        }
+      end
+     th.each {|t| t.join}
+    end
+    
+    def initial_play_time=(time)
+      @initial_play_time = time
+    end
+    
+    def initial_play_time
+      @initial_play_time
+    end
+    
+    def duration_in_milliseconds(tempo)
+      @duration.duration_in_milliseconds(tempo)
+    end
+    
   end
   
 end

data/lib/juicy/chord_progression.rb

@@ -5,21 +5,11 @@ module Juicy
     attr_accessor :chords
     
     def initialize
-      #@chords = []
-      #@chords << Chord.new(root: :C)
-      #@chords << Chord.new(root: :G, inversion: 1)-12
-      #@chords << Chord.new(root: :A, quality: :minor)
-      #@chords << Chord.new(root: :F, inversion: 1)-12
       @chords = []
       @chords << Chord.new(root: :C)
-      @chords << Chord.new(root: :F, inversion: 2)-12
-      @chords << Chord.new(root: :G, inversion: 1)-12
+      @chords << Chord.new(root: :F, inversion: 2)
+      @chords << Chord.new(root: :G, inversion: 1)
       @chords << Chord.new(root: :C)
-      #@progression = []
-      #@progression << ScaleDegree.new("I")
-      #@progression << ScaleDegree.new("IV")
-      #@progression << ScaleDegree.new("V")
-      #@progression << ScaleDegree.new("I")
     end
     
     def inspect
@@ -38,6 +28,15 @@ module Juicy
       output[0..-3]
     end
     
+    def to_a
+      [Chord.new(root: "C")]
+      @chords
+    end
+    
+    def initial_play_time
+      0
+    end
+    
     def play
       @chords.each do |chord|
         4.times {chord.play}

data/lib/juicy/duration.rb

@@ -0,0 +1,62 @@
+module Juicy
+
+  class Duration
+  
+    def initialize(duration)
+      @duration = parse_duration(duration)
+      
+    end
+    
+    def self.duration_of_quarter_note_in_milliseconds(tempo)
+      60_000.0/tempo
+    end
+    
+    def duration_in_milliseconds(tempo)
+      # how long a note is depends on the tempo and the musical duration
+      # e.g. at 120 bpm, and a duration of an eighth note, the duration
+      # in milliseconds would be 60_000.0/120/2
+      # milliseconds_per_second*seconds_per_minute/bpm/beats_of_given_type_per_quarter_note
+      60_000.0/tempo*beats_of_given_type_per_quarter_note
+    end
+    
+    def to_s
+      @duration.to_s
+    end
+  
+    private
+    
+    def beats_of_given_type_per_quarter_note
+      case @duration
+      when "quarter"
+        1.0
+      when "half"
+        2.0
+      when "whole"
+        4.0
+      when "eighth"
+        0.5
+      when "sixteenth"
+        0.25
+      else
+        1.0
+      end
+    end
+    
+    def parse_duration(duration)
+      case duration
+      when "quarter"
+        return "quarter"
+      when "half"
+        return "half"
+      when "eighth"
+        return "eighth"
+      when "sixteenth"
+        return "sixteenth"
+      else
+        return "quarter"
+      end
+    end
+  
+  end
+  
+end

data/lib/juicy/measure.rb

@@ -0,0 +1,13 @@
+
+module Juicy
+
+  class Measure
+  
+    def initialize(time_signature)
+      @beats_per_measure = time_signature[0]
+      @beat_type = Rational(1/time_signature[1])
+    end
+    
+  end
+  
+end

data/lib/juicy/melody.rb

@@ -0,0 +1,53 @@
+
+module Juicy
+
+  class Melody
+  
+    def initialize(chord_progression = ChordProgression.new, song = Song.new)
+      
+      @notes = [
+        Note.new("C", "half", 1),Note.new("E", "", 1),Note.new("G", "", 1),
+        Note.new("F", "", 1),Note.new("F", "eighth", 1),Note.new("G", "eighth", 1),Note.new("F", "half", 1),
+        Note.new("C", "half", 1),Note.new("E", "", 1),Note.new("G", "", 1),
+        Note.new("D", "", 1),Note.new("D", "eighth", 1),Note.new("E", "eighth", 1),Note.new("D", "half", 1)
+      ]
+      
+      @notes = []
+      
+      # given the chord progression, make the first note of every chord change a chord tone within 1 octave of the previous.
+      # then add in notes which over all step to the next, but don't have to be chord tones OR simply jump to the next chord tone
+      song.measures.each do |measure|
+        #until 
+      end
+      (10).times do
+        @notes << Note.new((["A", "C", "E"]).sample + [""].sample, ["eighth"].sample, [*(-1)..1].sample)
+      end
+      (10).times do
+        @notes << Note.new((["E", "G#", "B"]).sample + [""].sample, ["eighth"].sample, [*(-1)..1].sample)
+      end
+      (10).times do
+        @notes << Note.new((["A", "C", "E"]).sample + [""].sample, ["eighth"].sample, [*(-1)..1].sample)
+      end
+      
+      
+      sum_of_durations = 0
+      @notes.each do |note|
+        sum_of_durations += note.duration_in_milliseconds(song.tempo)
+        note.distance_from_beat_in_milliseconds = (sum_of_durations.round % Duration.duration_of_quarter_note_in_milliseconds(song.tempo).round)
+        note.plays_during(sum_of_durations.round / Duration.duration_of_quarter_note_in_milliseconds(song.tempo).round + 1)
+        #puts note.distance_from_beat_in_milliseconds
+      end
+      
+    end
+    
+    def to_a
+      @notes
+    end
+    
+    def initial_play_time
+      0
+    end
+    
+  end
+  
+end

data/lib/juicy/mode.rb

@@ -5,6 +5,24 @@ module Juicy
 
   class Mode
   
+    attr_reader :rotate
+  
+	def initialize(type = :ionian)
+	  @type = type
+	  @rotate = case @type
+	  when :major
+		0
+	  when :minor
+	    -2
+	  else
+	    0
+	  end
+	end
+	
+	def to_s
+	  "#{@type}"
+	end
+	
   end
   
 end

data/lib/juicy/note.rb

@@ -2,51 +2,150 @@ module Juicy
 
   class Note
   
-    attr_reader :name, :pitch
+    include Comparable
+  
+	  @@default_octave = 4
+    attr_reader :name, :pitch, :duration, :octave, :occupying_beat
+    attr_accessor :sum_of_queued_note_durations, :how_far_into_the_song_you_are
+    attr_accessor :distance_from_beat_in_milliseconds
     
-    def initialize(name)
+    def initialize(name = "A", duration = "quarter", octave_change = 0)
       @name = parse_note_name(name)
       @pitch = Pitch.new(@name)
+      @duration = Duration.new(duration)
+	    @octave = @@default_octave + octave_change
     end
     
+    def to_s
+      name = @name[0]
+      name += "#" if @name=~/sharp/
+      name += "b" if @name=~/flat/
+      "#{name}#{@octave}"
+    end
+	
     def inspect
       "#{@name}"
     end
     
-    def play(options = {duration: 200})
+    def play(options = {duration: 200, octave: (@octave-@@default_octave)})
+      if @name == :_
+        options[:volume] = 0
+      end
       @pitch.play(options)
     end
     
+    def prepare(options = {duration: 200, octave: (@octave-@@default_octave)})
+      options[:duration] = options[:duration] || 200
+      options[:octave] = options[:octave] || (@octave-@@default_octave)
+      if @name == :_
+        options[:volume] = 0
+      end
+        Thread.pass
+      @prepared_note = @pitch.prepare(options)
+      @prepared_note[:sleep_time] = @distance_from_beat_in_milliseconds/1000.0
+      #puts @prepared_note.status
+      until @prepared_note.status.eql? "sleep"
+        sleep 0.001
+        #puts @prepared_note.status
+      end
+      @prepared_note
+      self
+    end
+    
+    def play_prepared
+      #puts @prepared_note.status
+      #puts "playing"
+      until @prepared_note.status.eql? "sleep"
+        sleep 0.001
+        #puts @prepared_note.status
+        #Thread.pass
+      end
+      #Thread.pass
+      #puts "waking up"
+      @prepared_note.wakeup
+    end
+    
     def +(interval)
-      Note.new(PITCHES.key((PITCHES[@name]+interval) % 12))
+      step = PITCHES[@name]+interval
+      octave_change = step/12 #mathy stuff to figure out how many octaves were traversed (cant assume just one was
+      name = PITCHES.key((PITCHES[@name]+interval) % 12)
+      Note.new(name, @octave-@@default_octave + octave_change)
     end
     
     def -(interval)
-      puts self
-      puts PITCHES.key((PITCHES[@name]-interval) % 12)
       Note.new(PITCHES.key((PITCHES[@name]-interval) % 12))
     end
     
+    def <=>(other_note)
+      if same_octave
+        self.pitch <=> other_note.pitch
+      else
+        self.octave <=> other_note.octave
+      end
+    end
+    
+    def length
+      duration
+    end
+    
+    def size
+      duration
+    end
+    
+    def initial_play_time=(time)
+      @initial_play_time = time
+    end
+    
+    def initial_play_time
+      @initial_play_time
+    end
+    
+    def duration_in_milliseconds(tempo)
+      #puts tempo
+      @duration.duration_in_milliseconds(tempo)
+    end
+    
+    def self.default_octave
+      @@default_octave
+    end
+    
+    def plays_during(beat)
+      @occupying_beat = beat
+    end
+    
+    def plays_during?(beat)
+      beat == @occupying_beat
+    end
+    
     private
     
     def parse_note_name(name)
       # parses note name input
       # user should be able to say "A#" or "a#" or "a sharp" or "A_sharp" or "a_s"
       groups = name.to_s.match(/([a-gA-G])( |_)?(.*)/)
-      note_name = groups[1].upcase
-      unless groups[3].nil? || groups[3].empty?
-        note_name += case groups[3]
-        when /^(s|#)/
-          "_sharp"
-        when /^(f|b)/
-          "_flat"
-        else
-          puts "Unknown note modifier: '#{groups[3]}'"
+      puts "name: #{name}" if groups.nil?
+      if name.to_s.match "rest"
+        note_name = "_"
+      else
+        note_name = groups[1].upcase
+        unless groups[3].nil? || groups[3].empty?
+          note_name += case groups[3]
+          when /^(s|#)/
+            "_sharp"
+          when /^(f|b)/
+            "_flat"
+          else
+            puts "Unknown note modifier: '#{groups[3]}'"
+          end
         end
       end
       note_name.to_sym
     end
     
+    def same_octave
+      (self.octave <=> other_note.octave) == 0
+    end
+    
   end
 
 end

data/lib/juicy/pitch.rb

@@ -1,6 +1,7 @@
 module Juicy
 
   PITCHES = {
+    _: -1,
     A: 0,
     A_sharp: 1,
     B_flat: 1,
@@ -26,6 +27,7 @@ module Juicy
 
   class Pitch
   
+    include Comparable
     @@temperament = :equal
     @@pitch_standard = 440.0
     
@@ -44,6 +46,10 @@ module Juicy
       end
       
     end
+	
+    def to_s
+      "#{@frequency}"
+    end
     
     def tune
       if out_of_tune
@@ -66,8 +72,23 @@ module Juicy
       Win32::Sound.play_freq(options[:note].pitch.frequency, options[:note].duration)
     end
     
-    def play(options = {duration: 200})
-      Win32::Sound.play_freq(@frequency, options[:duration])
+    def play(options = {duration: 200, octave: 0, volume: 1})
+      options[:duration] ||= 200
+      options[:octave] ||= 0
+      options[:volume] ||= 1
+      Win32::Sound.play_freq(@frequency*2**(options[:octave]), options[:duration], options[:volume])
+    end
+    
+    def prepare(options = {duration: 200, octave: 0, volume: 1})
+      options[:duration] ||= 200
+      options[:octave] ||= 0
+      options[:volume] ||= 1
+      
+      return Thread.new{Win32::Sound.play_freq(@frequency*2**(options[:octave]), options[:duration], options[:volume], true)}
+    end
+    
+    def <=>(other_pitch)
+      self.frequency <=> other_pitch.frequency
     end
     
     private

data/lib/juicy/scale.rb

@@ -1,14 +1,88 @@
 
 module Juicy
 
-  CHROMATIC =  [1,1,1,1,1,1,1,1,1,1,1,1]
-  WHOLE_NOTE = [2,2,2,2,2,2]
-  OCTOTONIC =  [2,1,2,1,2,1,2,1]
-  PENTATONIC = [2,2,3,2,3]
-  DIATONIC =   [2,2,1,2,2,2,1]
+  SCALE_TYPES = {
+	  chromatic: [1,1,1,1,1,1,1,1,1,1,1,1],
+	  whole_note: [2,2,2,2,2,2],
+	  octotonic: [2,1,2,1,2,1,2,1],
+	  pentatonic: [2,2,3,2,3],
+	  diatonic: [2,2,1,2,2,2,1]
+  }  
+  #            0  1  2  3  4  5  6  7  8  9 10 11 12
+  #            |- |- |- |- |- |- |- |- |- |- |- |- |
+  #           do di re ri mi fa fi so si la li ti do
+  # chromatic  |- |- |- |- |- |- |- |- |- |- |- |- |
+  #           do    re    mi fa    so    la    ti do
+  # diatonic   |-  - |-  - |- |-  - |-  - |-  - |- |
+  #           do    re    mi       so    la       do
+  # pentatonic |-  - |-  - |-  -  - |-  - |-  -  - |
+  #           do    re    mi    fi    si    li    do
+  # whole note |-  - |-  - |-  - |-  - |-  - |-  - |
+  #           do    re ri    fa fi    si la    ti do
+  # octotonic  |-  - |- |-  - |- |-  - |- |-  - |- |
+  #
 
-  class Scale
-  
+    class Scale
+    include Enumerable
+
+    def initialize(type = :major, root = Note.new)
+      case type
+      when :major
+      @type = :diatonic
+      when :minor
+      @type = :diatonic
+      else
+      @type = type
+      end
+      @mode = Mode.new(type)
+      @root = root
+      generate_notes
+    
+    end
+    
+    def to_s
+      "scale type: #{@type}, mode: #{@mode}, root: #{@root}"
+    end
+    
+    def[](element)
+      
+    end
+    
+    def play
+    
+    end
+    
+    def mode=(type)
+      @mode = Mode.new(type)
+      generate_notes
+    end
+    
+    def root=(root)
+      @root = root
+      generate_notes
+    end
+    
+    def each
+      yield SCALE_TYPES[@type]
+    end
+    
+    def each_note
+      (SCALE_TYPES[@type].size+1).times do
+        yield @notes.next
+      end
+    end
+    
+    private
+    
+    def generate_notes
+      @notes = []
+      @notes << @root
+      SCALE_TYPES[@type].rotate(@mode.rotate).each do |step|
+        @notes << @notes[-1]+step
+      end
+      @notes = @notes.cycle
+    end
+    
   end
   
 end

data/lib/juicy/song.rb

@@ -3,6 +3,8 @@ module Juicy
 
   class Song
   
+    attr_reader :measures, :tempo
+  
     def initialize
     
       #a song has a key, a mode, voices, tempo, time signature, 
@@ -10,23 +12,45 @@ module Juicy
       @voices << Voice.new
       @key = :A
       @mode = :major
-      @tempo = 90.0
+      @tempo = 150.0
       @time_signature = [4,4]
+      @measures = []
+      4.times {@measures << Measure.new(@time_signature)}
       
+    end
+    
+    def play
+    
+      #  have musical construct yield notes up to a note manager/beat sequencer for each track
+      #  chords will eventually have a play style (various types of arpeggiation and such), but
+      #  for now they'll all just play all their notes at once for the given duration
       
-      # play Do Mi So Do
-      notes = [0, 4, 7, 12]
-      @voices[0].notes = [
-        Note.new(Pitch.new(440*2.0**(notes[0]/12)), beat_length_in_milliseconds),
-        Note.new(Pitch.new(440*2.0**(notes[1]/12)), beat_length_in_milliseconds),
-        Note.new(Pitch.new(440*2.0**(notes[2]/12)), beat_length_in_milliseconds),
-        Note.new(Pitch.new(440*2.0**(notes[3]/12)), beat_length_in_milliseconds)
-      ]
+      tracks = []
+    
+      chord_progression = ChordProgression.new
       
+      #tracks << Track.new(chord_progression.initial_play_time, chord_progression.to_a, @tempo)
+      
+      melody = Melody.new(chord_progression, self)
+      puts melody.inspect
+      tracks << Track.new(melody.initial_play_time, melody.to_a, @tempo)
+      melody = Melody.new(chord_progression, self)
+      puts melody.inspect
+      tracks << Track.new(melody.initial_play_time, melody.to_a, @tempo)
+      melody = Melody.new(chord_progression, self)
+      puts melody.inspect
+      tracks << Track.new(melody.initial_play_time, melody.to_a, @tempo)
+      melody = Melody.new(chord_progression, self)
+      puts melody.inspect
+      tracks << Track.new(melody.initial_play_time, melody.to_a, @tempo)
+      
+      Track.play_concurrently(tracks, @tempo)
+      
+    
     end
     
     def beat_length_in_milliseconds
-      60*1000/@tempo
+      60_000.0/@tempo
     end
     
   end

data/lib/juicy/track.rb

@@ -0,0 +1,205 @@
+
+module Juicy
+
+  class Track
+  
+    attr_accessor :notes
+  
+    def initialize(init_time, notes, tempo)
+    
+      @start_time = init_time
+      @notes = notes
+      @tempo = tempo
+    
+    end
+  
+    def play
+    
+      # prepare notes ahead of time, and play them at a specified time.
+      # each note must be prepared separately in it's own thread.
+      # only 20 threads are allowed to be alive at a time in a current track, and each track is preparing its notes seperately
+      # th = []
+      # while(notes_left_to_prepare)
+      #   if (th.count {|t| t.alive? }) <= 20
+      #     note = notes_left_to_prepare.shift
+      #     th << Thread.new do
+      #       note.prepare
+      #       sleep_amount = when_the_note_should_be_played - how_far_into_the_song_you_are
+      #       unless sleep_amount < 0
+      #         sleep sleep_amount
+      #       end
+      #       note.play_prepared
+      #     end
+      #   end
+      # end
+      # th.each {|t| t.join}
+    
+      notes = []
+      if @notes[0].kind_of? Chord
+        #notes << Thread.new { @notes.each { |chord| 4.times {chord.play} } }
+        chords_left_to_prepare = @notes.dup
+        @sum_of_queued_chord_durations = 0
+        until chords_left_to_prepare.size == 1
+          if (notes.count {|t| t.alive?} <= 20)
+            notes << Thread.new do
+              chord = chords_left_to_prepare.shift
+              puts "#{chord}: #{chord.duration}"
+              chord.sum_of_queued_chord_durations = @sum_of_queued_chord_durations
+              @sum_of_queued_chord_durations += chord.duration_in_milliseconds(@tempo)
+              chord.initial_play_time = @start_time + chord.sum_of_queued_chord_durations
+              chord.how_far_into_the_song_you_are = how_far_into_the_song_you_are
+              chord.prepare(duration: chord.duration_in_milliseconds(@tempo))
+              sleep_amount = (chord.initial_play_time - chord.how_far_into_the_song_you_are)/1000.0
+              unless sleep_amount < 0
+                sleep sleep_amount
+              end
+              Thread.pass
+              chord.play_prepared.join
+              #puts "tehe"
+              
+              
+            end
+          end
+          Thread.pass
+        end
+        
+      elsif @notes[0].kind_of? Note
+      
+        # @notes.each do |note|
+          # note.play
+        # end
+        notes_left_to_prepare = @notes.dup
+        @sum_of_queued_note_durations = 0
+        until notes_left_to_prepare.size == 1
+          #puts notes_left_to_prepare.size
+          if (notes.count {|t| t.alive? }) <= 20
+            #Thread.pass
+            notes << Thread.new do
+              note = notes_left_to_prepare.shift
+              puts "#{note}: #{note.duration}"
+              note.sum_of_queued_note_durations = @sum_of_queued_note_durations
+              @sum_of_queued_note_durations += note.duration_in_milliseconds(@tempo)
+              #puts @sum_of_queued_note_durations
+              note.initial_play_time = @start_time + note.sum_of_queued_note_durations
+              #puts "note.initial_play_time: #{note.initial_play_time}"
+              note.how_far_into_the_song_you_are = how_far_into_the_song_you_are
+              #puts "note.how_far_into_the_song_you_are: #{note.how_far_into_the_song_you_are}"
+              note.prepare(duration: note.duration_in_milliseconds(@tempo))
+              # puts "note.initial_play_time: #{note.initial_play_time}"
+              # puts "note.how_far_into_the_song_you_are: #{note.how_far_into_the_song_you_are}"
+              sleep_amount = (note.initial_play_time - note.how_far_into_the_song_you_are)/1000.0
+              #puts sleep_amount
+              unless sleep_amount < 0
+                sleep sleep_amount
+              end
+              Thread.pass
+              note.play_prepared
+            end
+            
+          end
+            Thread.pass
+        end
+      end
+      notes.each {|t| t.join}
+    end
+    
+    def self.tracks_is_empty(tracks)
+      empty = true
+      tracks.each do |track|
+        #puts track.object_id
+        puts track.notes.inspect
+        unless track.notes.empty?
+          empty = false
+        end
+      end
+      empty
+    end
+    
+    def self.play_concurrently(tracks, tempo)
+      @song_start_time = Time.now
+      threads = []
+      # iterate over each track over and over again, preparing notes in the current beat
+      # in each iteration, store the notes you've prepared into an array and store that
+      # array into the prepared_notes array which the playing thread will play notes from
+      # when it has enough to play.
+      # A track is an array of playable musical objects.  for now, these are individual
+      # notes or chords.  a chord is an array of individual notes
+      #
+      prepared_beats = []
+      out_of_notes_to_prepare = false
+      threads << Thread.new do
+        Thread.current[:name] = "prepare beats thread"
+        current_beat = 1
+        last_beat = 1
+        tracks.each do |track|
+          track.notes.each do |note|
+            last_beat = note.occupying_beat if note.occupying_beat > last_beat
+          end
+        end
+        until current_beat > last_beat
+          if prepared_beats.size <= 20
+            this_beats_notes = []
+            tracks.each do |track|
+              while !track.notes[0].nil? && track.notes[0].plays_during?(current_beat)
+                playable_thing = track.notes.shift
+                if playable_thing.kind_of?(Note)
+                  this_beats_notes << playable_thing.prepare(duration: playable_thing.duration_in_milliseconds(tempo))
+                elsif playable_thing.kind_of?(Chord)
+                  playable_thing.notes.each do |note|
+                    this_beats_notes << note.prepare(duration: note.duration_in_milliseconds(tempo))
+                  end
+                end
+              end
+            end
+            prepared_beats << this_beats_notes
+            current_beat += 1
+          end
+          Thread.pass
+        end
+        out_of_notes_to_prepare = true
+      end
+
+      threads << Thread.new do
+        Thread.current[:name] = "play prepared beats thread"
+        # when prepared_beats has at least a few beats to play (a measure's worth?)
+        # "start" the song by iterating through each element, waking up each note
+        # and then waiting the remainder of a beat's worth of milliseconds until the
+        # next beat
+        until (prepared_beats.size >= 2) || out_of_notes_to_prepare
+          sleep 0.01
+        end
+        last_note = Thread.new {}
+        time = Time.now
+        until prepared_beats.empty? && out_of_notes_to_prepare
+          time = Time.now
+          beat = prepared_beats.shift
+          beat.each do |note|
+            last_note = note.play_prepared
+          end
+          sleep rand(100..300)/1000.0
+          sleep_amount = Duration.duration_of_quarter_note_in_milliseconds(tempo)/1000.0 - (Time.now - time)
+          puts sleep_amount
+          sleep sleep_amount unless sleep_amount < 0
+        end
+        last_note.join
+      end
+      
+      #threads.each {|t| puts t[:name] }
+      threads.each {|t| t.join}
+    end
+    
+    private
+    
+    def total_duration_of_queued_notes_for_this_track
+      @sum_of_queued_note_durations
+    end
+    
+    def how_far_into_the_song_you_are
+      a = (1000*(Time.now - @song_start_time)).round
+      #puts "how_far_into_the_song_you_are: #{a}"
+      a
+    end
+    
+  end
+  
+end

data/lib/win32/wave_out_play_freq.rb

@@ -0,0 +1,131 @@
+
+require_relative 'win32-mmlib_structs'
+
+module Win32
+
+  class Sound
+    
+    # Plays a frequency for a specified duration at a given volume.
+    # Defaults are 440Hz, 1 second, full volume.
+    # Result is a single channel, 44100Hz sampled, 16 bit sine wave.
+    # If multiple instances are plays in simultaneous threads, 
+    # they will be started and played at the same time
+    #
+    # ex.: threads = []
+    #      [440, 660].each do |freq|
+    #        threads << Thread.new { Win32::Sound.play_freq(freq) }
+    #      end
+    #      threads.each { |th| th.join }
+    #
+    # the first frequency in this array (440) will wait until the
+    # thread for 660 finished calculating its PCM array and they
+    # will both start streaming at the same time.
+    #
+    def self.play_freq(frequency = 440, duration = 1000, volume = 1, pause_execution = false)
+    
+      if frequency > HIGH_FREQUENCY || frequency < LOW_FREQUENCY
+        raise ArgumentError, 'invalid frequency'
+      end
+      
+      if duration < 0 || duration > 5000
+        raise ArgumentError, 'invalid duration'
+      end
+    
+      stream(pause_execution) { |wfx|
+        data = generate_pcm_integer_array_for_freq(frequency, duration, volume)
+        data_buffer = FFI::MemoryPointer.new(:int, data.size)
+        data_buffer.write_array_of_int data
+        buffer_length = wfx[:nAvgBytesPerSec]*duration/1000
+        WAVEHDR.new(data_buffer, buffer_length)
+      }
+      
+    end
+  
+    private
+    
+    # Sets up a ready-made waveOut stream to push a PCM integer array to.
+    # It expects a block to be associated with the method call to which
+    # it will yield an instance of WAVEFORMATEX that the block uses
+    # to prepare a WAVEHDR to return to the function.
+    # The WAVEHDR can contain either a self-made PCM integer array
+    # or an array from a wav file or some other audio file converted
+    # to PCM.
+    # 
+    # This function will take the entire PCM array and create one
+    # giant buffer, so it is not intended for audio streams larger
+    # than 5 seconds.
+    #
+    # In order to play larger audio files, you will have to use the waveOut
+    # functions and structs to set up a double buffer to incrementally
+    # push PCM data to.
+    #
+    def self.stream(pause_execution)
+    
+      hWaveOut = HWAVEOUT.new
+      wfx = WAVEFORMATEX.new
+      
+      if ((error_code = waveOutOpen(hWaveOut.pointer, WAVE_MAPPER, wfx.pointer, 0, 0, 0)) != 0)
+        raise SystemCallError.new('waveOutOpen', FFI.errno)
+      end
+      
+      header = yield(wfx)
+      
+      if ((error_code = waveOutPrepareHeader(hWaveOut[:i], header.pointer, header.size)) != 0)
+        raise SystemCallError.new('waveOutPrepareHeader', FFI.errno)
+      end
+      
+      if pause_execution
+        Thread.stop
+        Thread.current[:sleep_time] ||= 0
+        sleep Thread.current[:sleep_time]
+      end
+      Thread.pass
+      
+      if (waveOutWrite(hWaveOut[:i], header.pointer, header.size) != 0)
+        raise SystemCallError.new('waveOutWrite', FFI.errno)
+      end
+      
+      while (waveOutUnprepareHeader(hWaveOut[:i], header.pointer, header.size) == 33)
+        sleep 0.1
+      end
+      
+      if ((error_code = waveOutClose(hWaveOut[:i])) != 0)
+        raise SystemCallError.new('waveOutClose', FFI.errno)
+      end
+      
+      self
+    end
+    
+    # Generates an array of PCM integers to play a particular frequency
+    # It also ramps up and down the volume in the first and last
+    # 200 milliseconds to prevent audio clicking.
+    # 
+    def self.generate_pcm_integer_array_for_freq(freq, duration, volume)
+    
+      data = []
+      ramp = 200.0
+      samples = (44100/2*duration/1000.0).floor
+      
+      samples.times do |sample|
+      
+        angle = (2.0*Math::PI*freq) * sample/samples * duration/1000
+        factor = Math.sin(angle)
+        x = 32768.0*factor*volume
+        
+        if sample < ramp
+          x *= sample/ramp
+        end
+        if samples - sample < ramp
+          x *= (samples - sample)/ramp
+        end
+        
+        data << x.floor
+      end
+      
+      data
+      
+    end
+    
+  end
+  
+end

data/lib/win32/win32-mmlib_structs.rb

@@ -0,0 +1,67 @@
+
+module Win32
+  
+  # Define an HWAVEOUT struct for use by all the waveOut functions.
+  # It is a handle to a waveOut stream, so starting up multiple
+  # streams using different handles allows for simultaneous playback.
+  # You never need to actually look at the struct, C takes care of
+  # its value.
+
+  class HWAVEOUT < FFI::Struct
+  
+    layout :i, :int
+    
+  end
+
+  # define WAVEFORMATEX which defines the format (PCM in this case)
+  # and various properties like sampling rate, number of channels, etc.
+
+  class WAVEFORMATEX < FFI::Struct
+  
+    def initialize(nSamplesPerSec = 44100, wBitsPerSample = 16, nChannels = 1, cbSize = 0)
+      self[:wFormatTag] = WAVE_FORMAT_PCM
+      self[:nChannels] = nChannels
+      self[:nSamplesPerSec] = nSamplesPerSec
+      self[:wBitsPerSample] = wBitsPerSample
+      self[:cbSize] = cbSize
+      self[:nBlockAlign] = (self[:wBitsPerSample] >> 3) * self[:nChannels]
+      self[:nAvgBytesPerSec] = self[:nBlockAlign] * self[:nSamplesPerSec]
+    end
+  
+    layout :wFormatTag,      :ushort,
+           :nChannels,       :ushort,
+           :nSamplesPerSec,  :ulong, 
+           :nAvgBytesPerSec, :ulong, 
+           :nBlockAlign,     :ushort,
+           :wBitsPerSample,  :ushort,
+           :cbSize,          :ushort
+    
+  end
+
+  #define WAVEHDR which is a header to a block of audio
+  #lpData is a pointer to the block of native memory that,
+  # in this case, is an integer array of PCM data
+
+  class WAVEHDR < FFI::Struct
+  
+    def initialize(lpData, dwBufferLength, dwFlags = 0, dwLoops = 1)
+      self[:lpData] = lpData
+      self[:dwBufferLength] = dwBufferLength
+      # self[:dwBytesRecorded] = dwBytesRecorded # used for waveIn, not waveOut
+      # self[:dwUser] = dwUser
+      self[:dwFlags] = dwFlags
+      self[:dwLoops] = dwLoops
+    end
+  
+    layout :lpData,          :pointer,
+           :dwBufferLength,  :ulong,
+           :dwBytesRecorded, :ulong,
+           :dwUser,          :ulong,
+           :dwFlags,         :ulong,
+           :dwLoops,         :ulong,
+           :lpNext,          :pointer,
+           :reserved,        :ulong
+      
+  end
+
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: juicy
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors:
 - Dominic Muller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-13 00:00:00.000000000 Z
-dependencies: []
+date: 2014-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: win32-sound
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
 description: Generates songs
 email: nicklink483@gmail.com
 executables: []
@@ -20,14 +34,20 @@ files:
 - lib/juicy.rb
 - lib/juicy/chord.rb
 - lib/juicy/chord_progression.rb
+- lib/juicy/duration.rb
 - lib/juicy/key.rb
+- lib/juicy/measure.rb
+- lib/juicy/melody.rb
 - lib/juicy/mode.rb
 - lib/juicy/note.rb
 - lib/juicy/pitch.rb
 - lib/juicy/scale.rb
 - lib/juicy/scale_degree.rb
 - lib/juicy/song.rb
+- lib/juicy/track.rb
 - lib/juicy/voice.rb
+- lib/win32/wave_out_play_freq.rb
+- lib/win32/win32-mmlib_structs.rb
 homepage: https://github.com/nicklink483/juicy
 licenses:
 - MIT