juicy 0.1.0 → 0.1.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZmVjZDlhNGNmZDc2MmM0NjQ3NjAxOWE4ZWU0NTAzNjYzMDBhYjE0MA==
+    NDk5YWVkNTIyMzU4OWQyOGE3NmM4MTllYWMwODFhMTJiNmZmMmU1Nw==
   data.tar.gz: !binary |-
-    ZDc4ODNhNzEzZTZiODBlYjRhZjQ3MjU4Y2ZkOGVjNmMyNzVjN2RmMA==
+    MGRiOTRkYzRiOWQzYmFhNWUyNjZmOWIzNzNlY2JmNzJjYjA5NTBjOQ==
 SHA512:
   metadata.gz: !binary |-
-    OTgwNjBkOTlhZDhiOTYyOTgxNTI5ZjNjMjMyNTdkMDQyY2RhMmNjMTJhOGMz
-    YjE3NmE3ZDQwMzA2YTNhZTFkZTM4YWIzOWEyYjU0NDI0MzM5MWVhNGVjMTg0
-    ZmQ5NDk1YzM5OTU1NjU4NzRmYjZmNzkxNDQ5OWJkNjI2ZDYxMjQ=
+    MzMyOTllNGI2ZmRhODIzYjg4ZjA4ODIwYWMwMGYwNTUyN2Y3MTdiODQ0N2Uw
+    N2I0MjJhN2MwZjk1ZjAxMTM4YTdiOGEzNWMxZWUwYmJjNWJjZTAyZjVkN2Uw
+    YWRmZjM3ZDUyOTMwZGIyNDY4MjMyOGEyM2M5ZTZhMzY5YzVjYTM=
   data.tar.gz: !binary |-
-    YTgyMWY4OTg2M2ZmMzBmMzRkNWQzZmRhZmU1MjMxNzg1MjBlN2MyM2NiZmFi
-    YzBhYjZlNTBlYzMyYzFiMTc3NDhhMjk2NmYyNWY1OGE2ZWRlYmEwMWE2NTNj
-    NWRlOTFkMWUzYmY2MmE3ZGE4NzVhMmEwNGU1YjExZDdlZmM2NWU=
+    NjlkMjZmNGNlMmUxMzU3NzUyNmFlNGViNzM0MWU4MTMzNjYwNmIwMzk5Yjdl
+    YjhmYjdlOWUzYjMzZmRlNmZlMzhkOTBmMjQyZGNlMmNkOTBjNzc1MmZkZjlm
+    MzFkYzg4NDU0YjJiNzE3MjYyZGFhYWZkMzQwYTQ1NjMyZTU5MDY=

data/bin/juicy.rb

@@ -1,6 +1,6 @@
 require_relative '../lib/juicy.rb'
 include Juicy
-play = false
+play = true
 # To make a pitch, give it a frequency.
 # By default, the frequency will be tuned to the nearest
 # frequency in equal temperament.
@@ -9,14 +9,16 @@ pitch = Pitch.new(445)
 puts pitch
 pitch.play if play
 
+sleep 0.3
 puts "----------"
 # A Note is a Pitch with a name.
 # You give it a note name and an octave
 #
-note = Note.new("G#", -1)
+note = Note.new(name: "G#", octave_change: -1)
 puts note
 note.play if play
 
+sleep 0.3
 puts "----------"
 # You can also add or subtract from a note to go to the next half step
 note += 1
@@ -26,9 +28,10 @@ note -= 2
 puts note
 note.play if play
 
+sleep 0.3
 puts "----------"
 # With this much, you can make your own scales!
-note = Note.new("C")
+note = Note.new(name: "C")
 major_scale = [2,2,1,2,2,2,1]
 major_scale.each do |step|
   puts note
@@ -38,10 +41,11 @@ end
 puts note
 note.play if play
 
+sleep 0.3
 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))
+scale = Scale.new(:major, Note.new(name: "D", octave_change: -1))
 puts scale
 scale.each_note do |note|
   note.play if play
@@ -58,8 +62,18 @@ end
 # current development work is being done on scale objects
 # and a beat sequencer to bring it all together.
 
-scale = Scale.new(:major, Note.new("G", -1))
+sleep 0.3
+scale = Scale.new(:major, Note.new(name: "G", octave_change: -1))
 puts scale
 scale.each_note do |note|
-  note.play
-end
+  note.play if play
+end
+
+puts
+
+# threads = []
+# 
+# [660, 440].each do |tone|
+#   threads << Thread.new {Win32::Sound.play_freq(tone, 200)}
+# end
+# threads.each {|t| t.join}

data/lib/juicy.rb

@@ -1,7 +1,6 @@
 # require 'win32-sound'
-# require_relative 'juicy/win32/sound.rb'
-require_relative 'win32/sound'
-require_relative 'win32/wave_out_play_freq'
+#require 'pry'
+require 'sound'
 
 require_relative 'juicy/pitch' #toned (or not) frequency in a chosen pitch space (temperament/intonation)
   require_relative 'juicy/note' #named pitch

data/lib/juicy/chord.rb

@@ -10,17 +10,18 @@ module Juicy
       
     }
     
-    attr_reader :duration
+    attr_reader :duration, :notes
     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)
+    def initialize(options = {root: Note.new(name: :C), quality: :major, inversion: 0, context: :none, duration: Duration.new("quarter")})
+      #binding.pry
+      @root = (options[:root].kind_of?(Note) ? options[:root] : Note.new(name: options[:root])) || Note.new(name: :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]
+      @notes = [@root + QUALITIES[@quality][0], @root + QUALITIES[@quality][1], @root + QUALITIES[@quality][2]]
     end
 	
     def to_s
@@ -47,7 +48,7 @@ module Juicy
       end
       
       pitches.each do |interval|
-        notes << Note.new(PITCHES.key((PITCHES[@root.name]+interval) % 12))
+        notes << Note.new(name: PITCHES.key((PITCHES[@root.name]+interval) % 12))
       end
       
       case style

data/lib/juicy/chord_progression.rb

@@ -4,12 +4,22 @@ module Juicy
   
     attr_accessor :chords
     
-    def initialize
-      @chords = []
-      @chords << Chord.new(root: :C)
-      @chords << Chord.new(root: :F, inversion: 2)
-      @chords << Chord.new(root: :G, inversion: 1)
-      @chords << Chord.new(root: :C)
+    def initialize(key, mode, numerals = [1,4,1,5])
+    
+      @numerals = numerals
+      
+      #given a key and a mode, a number can tell me what chord.
+      
+      @chords = [
+        Chord.new(root: "A", quality: :major),
+        Chord.new(root: "D", quality: :major),
+        Chord.new(root: "A", quality: :major),
+        Chord.new(root: "E", quality: :major)
+      ]
+     #@numerals.each do |numeral|
+     #  @chords << Chord.new(numeral)
+     #end
+      
     end
     
     def inspect

data/lib/juicy/duration.rb

@@ -2,8 +2,22 @@ module Juicy
 
   class Duration
   
+    DURATIONS = ["whole", "half", "quarter", "eighth", "sixteenth", "thirty-second", "sixty-fourth"]
+    MULTIPLIER = {:"" => 0, :triplet => -1, :dotted => 1}
+    
+    attr_reader :duration
+      
     def initialize(duration)
-      @duration = parse_duration(duration)
+      # @duration is a Rational number which represents the length of
+      # a note relative to a quarter note
+      # ex. Duration.new("dotted eighth")
+      #  @duration = Rational(3,4)
+      #
+      if duration.kind_of? Rational
+        @duration = duration
+      else
+        @duration = parse_duration(duration)
+      end
       
     end
     
@@ -22,39 +36,41 @@ module Juicy
     def to_s
       @duration.to_s
     end
+    
+    def to_f
+      @duration.to_f
+    end
+    
+    def +(other_duration)
+      Duration.new(@duration + other_duration.duration)
+    end
+    
+    def *(scalar)
+      Duration.new(@duration*scalar)
+    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
+      @duration.to_f
     end
     
+    #  takes user input and constructs a Rational number
+    #  ex. "dotted eighth"
+    #  Rational(3**
+    #
     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
+      
+      # parses note name input
+      # user should be able to say "dotted sixteenth" or "quarter" or "triplet eighth"
+      groups = duration.to_s.match(/^((dotted|triplet)( |_))?(.*)$/)
+      puts "duration: #{duration}" if groups.nil?
+      
+      d = DURATIONS.index(groups[4])
+      multiplier = MULTIPLIER[groups[2].to_s.to_sym]
+      #binding.pry
+      
+      Rational(4*(3**multiplier),(2**(multiplier+d)))
     end
   
   end

data/lib/juicy/measure.rb

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

data/lib/juicy/melody.rb

@@ -5,38 +5,72 @@ module Juicy
   
     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)
-      ]
-      
+      @song = song
       @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|
+      #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
+      #end
+      
+      # given a chord progression, make the first note of every measure a chord tone within 1 octave of the previous
+      
+      # while distance_between_notes > 1
+      #  insert notes between
+      # end
       
+      scale = Scale.new(@song.mode, Note.new(name: @song.key))
       
-      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
+      #new_note = 0
+      #old_note = 0
+      @song.measures.each_with_index do |measure, index|
+        @notes << Note.new(name: chord_progression.chords[index].notes[0].name, duration: :whole)
+        #new_note = Note.new(name: chord_progression.chords[index].notes.sample.name, duration: :whole, octave_change: [*(-1)..(-1)].sample)
+        #measure.insert_at(0, Note.new(name: "C"))
+        #old_note = new_note
       end
+      #binding.pry
+      
+      #song.measures.each_with_index do |measure, index|
+      #  @notes[index].duration = "half"
+      #  note = Note.new(name: chord_progression.chords[measure].notes.sample.name, duration: :half, octave_change: [*(-1)..(-1)].sample)
+      #  direction = (@notes[measure] <=> @notes[measure+1])
+      #  
+      #  insert = false
+      #  
+      #  if direction == -1
+      #    until note >= @notes[measure] && note <= @notes[measure+1]
+      #      #binding.pry
+      #      note = Note.new(name: [*"A".."G"].sample, duration: :half, octave_change: [*(-1)..(0)].sample)
+      #    end
+      #    insert = true
+      #  elsif direction == 1
+      #    until note <= @notes[measure] && note >= @notes[measure+1]
+      #      #binding.pry
+      #      note = Note.new(name: [*"A".."G"].sample, duration: :half, octave_change: [*(-1)..(0)].sample)
+      #    end
+      #    insert = true
+      #  end
+      #  @notes.insert(measure+1, note) if insert
+      #end
+      
+      #binding.pry
+      
+      #duration = ["half"]
+      #number_of_measures = 1
+      #number_of_measures.times do
+      #  chord_progression.chords.each do |chord|
+      #    number_of_beats_per_measure = 2
+      #    number_of_beats_per_measure.times do
+      #      puts chord.notes.inspect
+      #      @notes << Note.new(chord.notes.sample.name,  [duration].sample,  [*(-2)..0].sample)
+      #    end
+      #  end
+      #end
+      
+      
+
       
     end
     

data/lib/juicy/note.rb

@@ -4,16 +4,19 @@ module Juicy
   
     include Comparable
   
-	  @@default_octave = 4
+	  @@default_octave = 5
     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 = "A", duration = "quarter", octave_change = 0)
-      @name = parse_note_name(name)
+    def initialize(options = {name: "A", duration: :quarter, octave_change: 0})
+      options[:name] ||= "A"
+      options[:duration] ||= :quarter
+      options[:octave_change] ||= 0
+      @name = parse_note_name(options[:name])
       @pitch = Pitch.new(@name)
-      @duration = Duration.new(duration)
-	    @octave = @@default_octave + octave_change
+      @duration = Duration.new(options[:duration])
+	    @octave = @@default_octave + options[:octave_change]
     end
     
     def to_s
@@ -22,7 +25,7 @@ module Juicy
       name += "b" if @name=~/flat/
       "#{name}#{@octave}"
     end
-	
+	  
     def inspect
       "#{@name}"
     end
@@ -66,24 +69,31 @@ module Juicy
     end
     
     def +(interval)
-      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)
+      step(interval)
+      Note.new(name: new_name, octave_change: octave_change)
     end
     
     def -(interval)
-      Note.new(PITCHES.key((PITCHES[@name]-interval) % 12))
+      step(-1*interval)
+      Note.new(name: new_name, octave_change: octave_change)
     end
     
     def <=>(other_note)
-      if same_octave
+      if same_octave(other_note)
         self.pitch <=> other_note.pitch
       else
         self.octave <=> other_note.octave
       end
     end
     
+    def succ
+      return (self+1)
+    end
+    
+    def prev
+      return (self-1)
+    end
+    
     def length
       duration
     end
@@ -101,7 +111,6 @@ module Juicy
     end
     
     def duration_in_milliseconds(tempo)
-      #puts tempo
       @duration.duration_in_milliseconds(tempo)
     end
     
@@ -117,12 +126,29 @@ module Juicy
       beat == @occupying_beat
     end
     
+    def duration=(duration)
+      @duration = Duration.new(duration)
+    end
+    
     private
     
+    def octave_change
+      @octave - @@default_octave + @step/12
+    end
+    
+    def step(interval)
+      @step = PITCHES[@name]+interval
+    end
+    
+    def new_name
+      PITCHES.key((@step) % 12)
+    end
+    
     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])( |_)?(.*)/)
+      #binding.pry
       puts "name: #{name}" if groups.nil?
       if name.to_s.match "rest"
         note_name = "_"
@@ -136,13 +162,14 @@ module Juicy
             "_flat"
           else
             puts "Unknown note modifier: '#{groups[3]}'"
+            ""
           end
         end
       end
       note_name.to_sym
     end
     
-    def same_octave
+    def same_octave(other_note)
       (self.octave <=> other_note.octave) == 0
     end
     

data/lib/juicy/pitch.rb

@@ -25,14 +25,16 @@ module Juicy
     A_flat: 11
   }
 
+  # This class encapsulates all of the pitch mechanics for a given temperament.
+  # 
   class Pitch
-  
+
     include Comparable
     @@temperament = :equal
     @@pitch_standard = 440.0
-    
+
     attr_reader :frequency, :confidence
-  
+
     def initialize(pitch = @@pitch_standard, tune_now = true)
       
       if pitch.kind_of? Numeric
@@ -46,11 +48,11 @@ module Juicy
       end
       
     end
-	
+
     def to_s
       "#{@frequency}"
     end
-    
+
     def tune
       if out_of_tune
         step = Math.log(@frequency/440.0,2)*12
@@ -58,27 +60,29 @@ module Juicy
         @frequency = @@pitch_standard*2**((step.round)/12.0)
         @tuned = true
       end
+      self
     end
-    
+
     def +(interval)
       change_by (interval)
     end
-    
+
     def -(interval)
       change_by (-interval)
     end
-    
+
     def self.play(options = {duration: 200})
-      Win32::Sound.play_freq(options[:note].pitch.frequency, options[:note].duration)
+      binding.pry
+      Sound::Out.play_freq(options[:note].pitch.frequency, options[:note].duration)
     end
-    
+
     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])
+      ::Sound::Out.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
@@ -86,23 +90,23 @@ module Juicy
       
       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
-    
+
     def out_of_tune
       !@tuned
     end
-    
+
     def change_by (interval)
       if @@temperament.eql? :equal
         Pitch.new(@frequency*2**(interval/12.0))
       end
     end
-    
+
   end
 
 end

data/lib/juicy/scale.rb

@@ -62,8 +62,14 @@ module Juicy
       generate_notes
     end
     
+    #def each
+    #  yield SCALE_TYPES[@type]
+    #end
+    
     def each
-      yield SCALE_TYPES[@type]
+      (SCALE_TYPES[@type].size+1).times do
+        yield @notes.next.name
+      end
     end
     
     def each_note
@@ -72,6 +78,26 @@ module Juicy
       end
     end
     
+    def interval_between(note1, note2)
+      half_steps = 0
+      direction = (note1 <=> note2)
+      if direction == 0
+      elsif direction == -1
+        note = note1.dup
+        until (note <=> note2) == 0
+          note += 1
+          half_steps += 1
+        end
+      elsif direction == 1
+        note = note1.dup
+        until (note <=> note2) == 0
+          note -= 1
+          half_steps -= 1
+        end
+      end
+      half_steps
+    end
+    
     private
     
     def generate_notes

data/lib/juicy/song.rb

@@ -3,7 +3,7 @@ module Juicy
 
   class Song
   
-    attr_reader :measures, :tempo
+    attr_reader :measures, :tempo, :key, :mode
   
     def initialize
     
@@ -12,47 +12,77 @@ module Juicy
       @voices << Voice.new
       @key = :A
       @mode = :major
-      @tempo = 150.0
+      @tempo = 100.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
       
-      tracks = []
+      @tracks = []
     
-      chord_progression = ChordProgression.new
+      key = Key.new
+      chord_progression = ChordProgression.new(@key, @mode)
       
-      #tracks << Track.new(chord_progression.initial_play_time, chord_progression.to_a, @tempo)
+      @tracks << Track.new(0, demo_melody, @tempo)
+      number_of_tracks = 1
+      number_of_tracks.times do
+        melody = Melody.new(chord_progression, self)
+        @tracks << Track.new(melody.initial_play_time, melody, @tempo)
+      end
       
-      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)
+    end
+    
+    def play
       
-      Track.play_concurrently(tracks, @tempo)
+      Track.play_concurrently(@tracks, @tempo)
       
-    
     end
     
     def beat_length_in_milliseconds
       60_000.0/@tempo
     end
     
+    def demo_melody
+      @demo_melody ||= [
+        Note.new(name: "A", duration: :eighth, octave_change: -1),
+        Note.new(name: "E", duration: :eighth, octave_change: -1),
+        Note.new(name: "C#", duration: :eighth, octave_change: -1),
+        Note.new(name: "E", duration: :eighth, octave_change: -1),
+        Note.new(name: "A", duration: :eighth, octave_change: 0),
+        Note.new(name: "E", duration: :eighth, octave_change: -1),
+        Note.new(name: "C#", duration: :eighth, octave_change: -1),
+        Note.new(name: "E", duration: :eighth, octave_change: -1),
+        Note.new(name: "A", duration: :eighth, octave_change: -1),
+        Note.new(name: "E", duration: :eighth, octave_change: -1),
+        Note.new(name: "C#", duration: :eighth, octave_change: -1),
+        Note.new(name: "E", duration: :eighth, octave_change: -1),
+        Note.new(name: "A", duration: :eighth, octave_change: 0),
+        Note.new(name: "E", duration: :eighth, octave_change: -1),
+        Note.new(name: "C#", duration: :eighth, octave_change: -1),
+        Note.new(name: "E", duration: :eighth, octave_change: -1),
+        
+        Note.new(name: "D", duration: :eighth, octave_change: -1),
+        Note.new(name: "A", duration: :eighth, octave_change: 0),
+        Note.new(name: "F#", duration: :eighth, octave_change: -1),
+        Note.new(name: "A", duration: :eighth, octave_change: 0),
+        Note.new(name: "D", duration: :eighth, octave_change: 0),
+        Note.new(name: "A", duration: :eighth, octave_change: 0),
+        Note.new(name: "F#", duration: :eighth, octave_change: -1),
+        Note.new(name: "A", duration: :eighth, octave_change: 0),
+        Note.new(name: "D", duration: :eighth, octave_change: -1),
+        Note.new(name: "A", duration: :eighth, octave_change: 0),
+        Note.new(name: "F#", duration: :eighth, octave_change: -1),
+        Note.new(name: "A", duration: :eighth, octave_change: 0),
+        Note.new(name: "D", duration: :eighth, octave_change: 0),
+        Note.new(name: "A", duration: :eighth, octave_change: 0),
+        Note.new(name: "F#", duration: :eighth, octave_change: -1),
+        Note.new(name: "A", duration: :eighth, octave_change: 0)
+      ]
+    end
+    
   end
   
 end

data/lib/juicy/track.rb

@@ -8,9 +8,24 @@ module Juicy
     def initialize(init_time, notes, tempo)
     
       @start_time = init_time
-      @notes = notes
+      @notes = notes.to_a
       @tempo = tempo
+      
+      @track_length_in_milliseconds = 0
+      @notes.each do |note|
+        note.distance_from_beat_in_milliseconds = distance_from_beat_in_milliseconds
+        note.plays_during occupying_beat
+        @track_length_in_milliseconds += note.duration_in_milliseconds(@tempo)
+      end
+    
+    end
     
+    def distance_from_beat_in_milliseconds
+      (@track_length_in_milliseconds.round % Duration.duration_of_quarter_note_in_milliseconds(@tempo).round)
+    end
+    
+    def occupying_beat
+      @track_length_in_milliseconds.round / Duration.duration_of_quarter_note_in_milliseconds(@tempo).round + 1
     end
   
     def play
@@ -116,14 +131,14 @@ module Juicy
     end
     
     def self.play_concurrently(tracks, tempo)
-      @song_start_time = Time.now
+      #@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
+      # notes or chords.  a chord is an array of individual notes to be played simultaneously
       #
       prepared_beats = []
       out_of_notes_to_prepare = false
@@ -131,12 +146,25 @@ module Juicy
         Thread.current[:name] = "prepare beats thread"
         current_beat = 1
         last_beat = 1
+        # find the final beat of all tracks combined
         tracks.each do |track|
-          track.notes.each do |note|
-            last_beat = note.occupying_beat if note.occupying_beat > last_beat
+          track.notes.each do |playable_thing|
+            if playable_thing.kind_of?(Note)
+              last_beat = playable_thing.occupying_beat if playable_thing.occupying_beat > last_beat
+            elsif playable_thing.kind_of?(Chord)
+              playable_thing.notes.each do |note|
+                last_beat = note.occupying_beat if note.occupying_beat > last_beat
+              end
+            end
           end
         end
+        # until you've prepared all the notes, prepare each note in an array with
+        # other notes who occupy the same beat
         until current_beat > last_beat
+          # only add/prepare beats if there are fewer than 20 prepared already
+          # so that we don't hit the thread limit.  This assumes that a buffer of 20
+          # is sufficent and that each beat has, on average, fewer than 30 notes.
+          # if there are too many notes, weird things start to happen, so don't do that.
           if prepared_beats.size <= 20
             this_beats_notes = []
             tracks.each do |track|
@@ -154,6 +182,7 @@ module Juicy
             prepared_beats << this_beats_notes
             current_beat += 1
           end
+          # Pass thread execution over to note playing so that there is no delay in playback
           Thread.pass
         end
         out_of_notes_to_prepare = true
@@ -165,26 +194,27 @@ module Juicy
         # "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
+        until (prepared_beats.size >= 4) || 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
+          # take the next beat's worth of notes
           beat = prepared_beats.shift
+          # start each note in the beat as its own thread
           beat.each do |note|
             last_note = note.play_prepared
           end
-          sleep rand(100..300)/1000.0
+          # to ensure simultaneity, sleep for however much longer a beat lasts
+          # at the current tempo
           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
     

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: juicy
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Dominic Muller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-02 00:00:00.000000000 Z
+date: 2014-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: win32-sound
+  name: sound
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.0.2
 description: Generates songs
 email: nicklink483@gmail.com
 executables: []
@@ -46,9 +52,7 @@ files:
 - 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
+homepage: https://github.com/RSMP/juicy
 licenses:
 - MIT
 metadata: {}
@@ -73,3 +77,4 @@ signing_key:
 specification_version: 4
 summary: Song writing tool
 test_files: []
+has_rdoc: 

data/lib/win32/wave_out_play_freq.rb

@@ -1,131 +0,0 @@
-
-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

@@ -1,67 +0,0 @@
-
-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