musicality 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 25e0c57192fe59be6b7839c2eb1b7a0ebfca7d5e
+  data.tar.gz: 3e5b8efeddfdcb1a7fa4b1f78a8752204109779e
+SHA512:
+  metadata.gz: 41c88ca97959bdb89f55e27a69505a77a3f045c5ef6406d4c9d3fba61969f60ef3a7e9ad3e94d4323217b3bc45d6d972cd06ee070448a6f34c69b3b93b41fd49
+  data.tar.gz: b6019f6508f05bfd4d8cfb82e6bd9b724b3a4b6af0e1dde1f2cf2eb5d625836fcc00a47162f4d2457a74d3cd9b81f14fb2f8ed8438eb96a4435595a9c155c10f

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/exec/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in musicality.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 James Tunnell
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# Musicality
+
+The library is based around an abstract representation for music notation. From here, functions are built up to make composing elaborate pieces in this notation representation more manageable. Finally, music performance is supported by providing translation to common formats, like MIDI.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'musicality'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install musicality
+
+## Usage
+
+Raw notation objects can be created like this:
+```ruby
+require 'musicality'
+include Musicality
+include Pitches
+include Dynamics
+
+single = Note.quarter(Ab4)
+rest = Note.quarter
+chord = Note.whole([C3,E3,G3])
+part = Part.new(MP, notes:[single,rest,chord])
+```
+
+Or, a compact, string representation can be used, instead.
+```ruby
+Part.new(FF, "/4Ab4 /4 1C3,E3,G3".to_notes)
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/musicality/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require "bundler/gem_tasks"
+require 'rake'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task :test    => :spec
+task :default => :spec
+
+def rb_fname fname
+  basename = File.basename(fname, File.extname(fname))
+  dirname = File.dirname(fname)
+  "#{dirname}/#{basename}.rb"
+end
+
+task :build_parsers do
+  wd = Dir.pwd
+  Dir.chdir "lib/musicality/notation/parsing"
+  parser_files = Dir.glob(["**/*.treetop","**/*.tt"])
+  
+  if parser_files.empty?
+    puts "No parsers found"
+    return
+  end
+
+  build_list = parser_files.select do |fname|
+    rb_name = rb_fname(fname)
+    !File.exists?(rb_name) || (File.mtime(fname) > File.mtime(rb_name))
+  end
+  
+  if build_list.any?
+    puts "building parsers:"
+    build_list.each do |fname|
+      puts "  #{fname} -> #{rb_fname(fname)}"
+      `tt -f #{fname}`
+    end
+  else
+    puts "Parsers are up-to-date"
+  end
+  Dir.chdir wd
+end
+task :spec => :build_parsers
+
+task :make_examples do
+  current_dir = Dir.getwd
+  examples_dir = File.join(File.dirname(__FILE__), 'examples')
+  Dir.chdir examples_dir
+  
+  examples = []
+  Dir.glob('**/*.rb') do |file|
+    examples.push File.expand_path(file)
+  end
+  
+  examples.each do |example|
+    dirname = File.dirname(example)
+    filename = File.basename(example)
+    
+    Dir.chdir dirname
+    ruby filename
+  end
+
+  Dir.chdir current_dir
+end

data/bin/midify

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+exe_name = File.basename(__FILE__)
+
+doc = <<DOCOPT
+Loads a musicality score from YAML file, and converts it to a MIDI file.
+
+Usage:
+  #{exe_name} <input> [PART PROGRAM] ... [options]
+  #{exe_name} <input> <output> [PART PROGRAM] ... [options]
+  #{exe_name} -h | --help
+  #{exe_name} --version
+
+Arguments:
+  input A musicality score file (may be packed as a hash) in YAML format
+  output Midi filename
+  PART name of a part in the score
+  PROGRAM MIDI program (instrument) number for the given part
+  
+Options:
+  --srate=SRATE sampling rate for converting tempo-based score to time-based
+                score, and for sampling dynamic change values [default: 200]
+  -h --help     Show this screen.
+  --version     Show version.
+
+DOCOPT
+
+require 'docopt'
+begin
+  args = Docopt::docopt(doc)
+  puts args
+rescue Docopt::Exit => e
+  puts e.message
+  exit
+end
+
+require 'yaml'
+require 'musicality'
+include Musicality
+
+fin_name = args["<input>"]
+File.open(fin_name) do |fin|
+  print "Reading file '#{fin_name}'..."
+  score = YAML.load(fin.read)
+  
+  if score.is_a? Hash
+    score = Score.unpack(score)
+  end
+  puts "done"
+  
+  unless score.is_a? Score::Timed
+    print "Converting to timed score..."
+    score = score.to_timed(args["--srate"])
+    puts "done"
+  end
+  
+  if score.valid?
+    part_names = args["PART"]
+    program_nums = args["PROGRAM"].map {|str| str.to_i }
+    instr_map = Hash[[part_names,program_nums].transpose]
+    
+    print "Making MIDI sequence..."
+    sequencer = ScoreSequencer.new(score)
+    seq = sequencer.make_midi_seq(instr_map)
+    puts "done"  
+  
+    fout_name = args["<output>"]
+    if fout_name.nil?
+      fout_name = "#{File.dirname(fin_name)}/#{File.basename(fin_name,File.extname(fin_name))}.mid"
+    end
+    print "Writing MIDI file '#{fout_name}'..."
+    File.open(fout_name, 'wb'){ |fout| seq.write(fout) }
+    puts "done"    
+  else
+    puts "Score is not valid. See errors:"
+    puts score.errors.join("\n")
+  end
+end

data/examples/hip.rb

@@ -0,0 +1,32 @@
+require 'musicality'
+require 'yaml'
+
+include Musicality
+include Pitches
+include Articulations
+include Meters
+
+score = Score::Measured.new(FOUR_FOUR,120) do |s|
+  s.program = Program.new([0...2, 0...2,2...4,0...2])
+  s.parts["lead"] = Part.new(Dynamics::MF) do |p|
+    riff = "/6Bb3 /4 /12Db4= /6Db4= /36Db4 /36Eb4 /36Db4 /6Ab3 /12Db4 \
+            /6Bb3 /4 /12Db4= /4Db4=                      /8=Db4 /8C4".to_notes
+    p.notes = riff + riff.map {|n| n.transpose(2) }
+  end
+  
+  s.parts["bass"] = Part.new(Dynamics::MP) do |p|
+    riff = "/6Bb2 /4 /3Ab2 /6F2 /12Ab2 \
+            /6Bb2 /4 /3Ab2 /4Ab2".to_notes
+    p.notes = riff + riff.map {|n| n.transpose(2) }
+  end
+end
+
+name = File.basename(__FILE__,".rb")
+
+File.open("#{name}.yml", "w") do |file|
+  file.write score.to_yaml
+end
+
+File.open("#{name}_packed.yml", "w") do |file|
+  file.write score.pack.to_yaml
+end

data/examples/missed_connection.rb

@@ -0,0 +1,26 @@
+require 'musicality'
+require 'yaml'
+
+include Musicality
+include Pitches
+include Articulations
+include Meters
+
+score = Score::Measured.new(FOUR_FOUR, 120) do |s|
+  s.program = Program.new([0...2,0...6])
+  s.parts["bass"] = Part.new(Dynamics::MF) do |p|
+    p.notes =  "/4Eb2 /4 /4Bb2 /4 /4Eb2 /8 /8B2 /4Bb2 /4Ab2".to_notes
+    p.notes += "/4Bb2 /8 /8F3= /2F3 /4Bb2 /8 /8F3= /2F3".to_notes
+    p.notes += "/4B2 /8 /8Gb3= /2Gb3 /8 /8Gb3= /2Gb3".to_notes
+  end
+end
+
+name = File.basename(__FILE__,".rb")
+
+File.open("#{name}.yml", "w") do |file|
+  file.write score.to_yaml
+end
+
+File.open("#{name}_packed.yml", "w") do |file|
+  file.write score.pack.to_yaml
+end

data/examples/song1.rb

@@ -0,0 +1,33 @@
+require 'musicality'
+require 'yaml'
+
+include Musicality
+include Pitches
+include Articulations
+include Meters
+
+score = Score::Measured.new(FOUR_FOUR, 120) do |s|
+  s.program = Program.new([ 0...4.0, 0...4.0 ])
+  
+  s.parts[1] = Part.new(Dynamics::MF) do |p|
+    p.notes = "3/8C2 /4Eb2 5/16F2 /16Eb2 \
+               /8 /4C2 /4Eb2 3/8 \
+               3/8C2 /4Eb2 5/16F2 /16Eb2 \
+               /8 /4C2 /4Eb2".to_notes
+  end
+  
+  s.parts[2] = Part.new(Dynamics::MF) do |p|
+    p.notes = "/8 /8Bb3 /8Bb3 /8Bb3 /8Bb3 /4C4 /4A3 /8G3 /8F3 5/16=G3 /16=F3 /8E3 /8 \
+               /8 /8Bb3 /8Bb3 /8Bb3 /8Bb3 /4C4 /8A3 /8E4 /8=E4 /8=D4 /8C4".to_notes
+  end
+end
+
+name = File.basename(__FILE__,".rb")
+
+File.open("#{name}.yml", "w") do |file|
+  file.write score.to_yaml
+end
+
+File.open("#{name}_packed.yml", "w") do |file|
+  file.write score.pack.to_yaml
+end

data/examples/song2.rb

@@ -0,0 +1,32 @@
+require 'musicality'
+require 'yaml'
+
+include Musicality
+include Pitches
+include Meters
+
+score = Score::Measured.new(FOUR_FOUR, 120) do |s|
+  s.program = Program.new([0...4.0, 0...4.0 ])
+  
+  s.parts[1] = Part.new(Dynamics::MF) do |p|
+    p.notes = "1C4 1Bb3 1Ab3 /2G3 /2Bb3".to_notes
+  end
+  
+  s.parts[2] = Part.new(Dynamics::MF) do |p|
+    p.notes = "3/8E5 1D5 1C5 5/8C5 /2C5 /2D5".to_notes
+  end
+  
+  s.parts[3] = Part.new(Dynamics::MF) do |p|
+    p.notes = "/8 /4G5 /2F5 /4 /4F5 /2Eb5 /4 /4Eb5 /2Eb5 /8 /2Eb5 /2F5".to_notes
+  end
+end
+
+name = File.basename(__FILE__,".rb")
+
+File.open("#{name}.yml", "w") do |file|
+  file.write score.to_yaml
+end
+
+File.open("#{name}_packed.yml", "w") do |file|
+  file.write score.pack.to_yaml
+end

data/lib/musicality/errors.rb

@@ -0,0 +1,9 @@
+module Musicality
+  class NonZeroError < StandardError; end
+  class NegativeError < StandardError; end
+  class NonPositiveError < StandardError; end
+  class NonIntegerError < StandardError; end
+  class NonRationalError < StandardError; end
+  class NonIncreasingError < StandardError; end
+  class NotValidError < StandardError; end
+end

data/lib/musicality/notation/conversion/change_conversion.rb

@@ -0,0 +1,19 @@
+module Musicality
+
+class Change
+  class Immediate < Change
+    def offsets base_offset
+      [ base_offset ]
+    end
+  end
+  
+  class Gradual < Change
+    def offsets base_offset
+      initial = base_offset - @elapsed
+      final = initial + @total_duration
+      [ initial, base_offset, base_offset + @impending, final ]
+    end
+  end
+end
+
+end

data/lib/musicality/notation/conversion/measure_note_map.rb

@@ -0,0 +1,40 @@
+module Musicality
+
+module Conversion
+  # Converte offsets from measure-based to note-based.
+  # @param [Array] measure_offsets Measure offsets to be converted
+  # @param [Hash] measure_durations Map measure durations to measure offsets where the duration takes effect.
+  # @raise [NonZeroError] if first measure duration is not mapped to offset 0
+  def self.measure_note_map measure_offsets, measure_durations
+    mnoff_map = {}
+    moffs = measure_offsets.uniq.sort
+    mdurs = measure_durations.sort
+    cur_noff = 0.to_r
+    j = 0 # next measure offset to be converted
+    
+    if mdurs[0][0] != 0
+      raise NonZeroError, "measure offset of 1st measure duration must be 0, not #{mdurs[0][0]}"
+    end
+    
+    (0...mdurs.size).each do |i|
+      cur_moff, cur_mdur = mdurs[i]
+      if i < (mdurs.size - 1)
+        next_moff = mdurs[i+1][0]        
+      else
+        next_moff = Float::INFINITY
+      end
+      
+      while(j < moffs.size && moffs[j] <= next_moff) do
+        moff = moffs[j]
+        mnoff_map[moff] = cur_noff + (moff - cur_moff)*cur_mdur
+        j += 1
+      end
+      
+      cur_noff += (next_moff - cur_moff) * cur_mdur
+    end
+    
+    return mnoff_map
+  end
+end
+
+end

data/lib/musicality/notation/conversion/measured_score_conversion.rb

@@ -0,0 +1,70 @@
+module Musicality
+
+class Score
+  class Measured < TempoBased
+    # Convert to unmeasured score by converting measure-based offsets to
+    # note-based offsets, and eliminating the use of meters. Also, tempo is
+    # coverted from beats-per-minute to quarter-notes per minute.
+    def to_unmeasured
+      MeasuredScoreConverter.new(self).convert_score
+    end
+
+    def to_timed tempo_sample_rate
+      unmeasured = MeasuredScoreConverter.new(self).convert_score
+      unmeasured.to_timed(tempo_sample_rate)
+    end
+    
+    def measure_note_map
+      Conversion::measure_note_map(measure_offsets,measure_durations)
+    end
+    
+    def measure_offsets
+      moffs = Set.new([0.to_r])
+      
+      @tempo_changes.each do |moff,change|
+        moffs += change.offsets(moff)
+      end
+      
+      @meter_changes.keys.each {|moff| moffs.add(moff) }
+      
+      @parts.values.each do |part|
+        part.dynamic_changes.each do |moff,change|
+          moffs += change.offsets(moff)
+        end
+      end
+      
+      @program.segments.each do |seg|
+        moffs.add(seg.first)
+        moffs.add(seg.last)
+      end
+      
+      return moffs.sort
+    end
+  
+    def beat_durations
+      bdurs = @meter_changes.map do |offset,change|
+        [ offset, change.value.beat_duration ]
+      end.sort
+      
+      if bdurs.empty? || bdurs[0][0] != 0
+        bdurs.unshift([0,@start_meter.beat_duration])
+      end
+    
+      return bdurs
+    end
+    
+    def measure_durations
+      mdurs = @meter_changes.map do |offset,change|
+        [ offset, change.value.measure_duration ]
+      end.sort
+      
+      if mdurs.empty? || mdurs[0][0] != 0
+        mdurs.unshift([0,@start_meter.measure_duration])
+      end
+    
+      return Hash[ mdurs ]
+    end  
+  end
+end
+
+end

data/lib/musicality/notation/conversion/measured_score_converter.rb

@@ -0,0 +1,95 @@
+module Musicality
+
+# Converts measured score to unmeasured by converting measure-based offsets
+# and durations to note-based offsets, and eliminating the use of meters.
+# Also, tempo is coverted from beats-per-minute to quarter-notes per minute.
+class MeasuredScoreConverter
+  def initialize score
+    unless score.valid?
+      raise NotValidError, "The given score can not be converted because \
+                            it is invalid, with these errors: #{score.errors}"
+    end
+    
+    @score = score
+    @mnoff_map = score.measure_note_map
+  end
+  
+  def convert_score
+    Score::Unmeasured.new(convert_start_tempo,
+      parts: convert_parts, program: convert_program,
+      tempo_changes: convert_tempo_changes)
+  end
+  
+  def convert_parts
+    Hash[ @score.parts.map do |name,part|
+      new_dcs = Hash[ part.dynamic_changes.map do |moff,change|
+        case change
+        when Change::Immediate
+          [@mnoff_map[moff],change.clone]
+        when Change::Gradual
+          noff1, noff2, noff3, noff4 = change.offsets(moff).map {|x| @mnoff_map[x] }
+          [noff2, Change::Gradual.new(change.value,
+            noff3-noff2, noff2-noff1, noff4-noff3)]
+        end
+      end ]
+      new_notes = part.notes.map {|n| n.clone }
+      [name, Part.new(part.start_dynamic,
+        notes: new_notes, dynamic_changes: new_dcs)]
+    end ]
+  end
+  
+  def convert_program
+    Program.new(
+      @score.program.segments.map do |seg|
+        @mnoff_map[seg.first]...@mnoff_map[seg.last]
+      end
+    )
+  end
+  
+  def convert_start_tempo
+    Tempo::BPM.to_qnpm(@score.start_tempo, @score.start_meter.beat_duration)
+  end
+  
+  def convert_tempo_changes
+    tcs = {}
+    bdurs = @score.beat_durations
+    
+    @score.tempo_changes.each do |moff,change|
+      bdur = bdurs.select {|x,y| x <= moff}.max[1]
+      tempo = change.value
+      
+      case change
+      when Change::Immediate
+        tcs[@mnoff_map[moff]] = Change::Immediate.new(Tempo::BPM.to_qnpm(tempo,bdur))
+      when Change::Gradual
+        start_moff, end_moff = moff, moff + change.duration
+        start_noff, end_noff = @mnoff_map[start_moff], @mnoff_map[end_moff]
+        
+        initial_moff, final_moff = start_moff - change.elapsed, end_moff + change.remaining
+        initial_noff, final_noff = @mnoff_map[initial_moff], @mnoff_map[final_moff]
+        
+        more_bdurs = bdurs.select {|x,y| x > start_moff && x < end_moff }
+        cur_noff, cur_bdur = start_noff, bdur
+        
+        more_bdurs.each do |next_moff, next_bdur|
+          next_noff = @mnoff_map[next_moff]
+          elapsed = cur_noff - initial_noff
+          impending = next_noff - cur_noff
+          remaining = final_noff - next_noff
+          tempo2 = Tempo::BPM.to_qnpm(tempo, cur_bdur)
+          tcs[cur_noff] = Change::Gradual.new(tempo2, impending, elapsed, remaining)
+          cur_noff, cur_bdur = next_noff, next_bdur
+        end
+        elapsed = cur_noff - initial_noff
+        impending = end_noff - cur_noff
+        remaining = final_noff - end_noff
+        tempo2 = Tempo::BPM.to_qnpm(tempo, cur_bdur)
+        tcs[cur_noff] = Change::Gradual.new(tempo2, impending, elapsed, remaining)
+      end
+    end
+    
+    return tcs
+  end
+end
+
+end

data/lib/musicality/notation/conversion/note_time_converter.rb

@@ -0,0 +1,68 @@
+module Musicality
+  
+# Convert offsets in unmeasured note time to just plain time. 
+class NoteTimeConverter
+  # @param [ValueComputer] tempo_computer Given an offset, returns tempo
+  # value in quarter-notes-per-minute
+  # @param [Numeric] sample_rate Rate at which tempo values are sampled
+  # in the conversion (samples/sec).
+  def initialize tempo_computer, sample_rate
+    @tempo_computer = tempo_computer
+    @sample_period = Rational(1,sample_rate)
+  end
+  
+  def notes_per_second_at offset
+    Tempo::QNPM.to_nps(@tempo_computer.value_at offset)
+  end
+  
+  # Calculate the time elapsed between given start/end note offset. Using the
+  # notes-per-second values over this interval, note duration for each sample is
+  # known and accumulated as samples are taken. When accumulated note duration
+  # passes the given desired duration (end_offset - start_offset), the number of
+  # samples taken will indicated the corresponding time duration. Then there
+  # is adjustment for last sample taken, which likely goes past the desired note
+  # duration.
+  #
+  # @param [Numeric] start_offset the starting note offset.
+  # @param [Numeric] end_offset the ending note offset.
+  # @raise [ArgumentError] if end offset is less than starting offset.
+  def time_elapsed start_offset, end_offset
+    raise ArgumentError "note end is less than note begin" if end_offset < start_offset
+    
+    time_samples = 0
+    offset = start_offset
+    
+    while offset < end_offset
+      notes_per_sec = notes_per_second_at offset
+      notes_per_sample = notes_per_sec * @sample_period
+      
+      if (offset + notes_per_sample) > end_offset
+        #interpolate between offset and end_offset
+        perc = (end_offset - offset) / notes_per_sample
+        time_samples += perc
+        offset = end_offset
+      else
+        time_samples += 1
+        offset += notes_per_sample
+      end
+    end
+    
+    return time_samples * @sample_period
+  end
+
+  #map absolute note offsets to relative time offsets
+  def note_time_map offsets
+    time_counter = 0.0
+    sorted_offsets = offsets.sort
+    note_time_map = { sorted_offsets.first => time_counter }
+    
+    for i in 1...sorted_offsets.count do
+      time_counter += time_elapsed(sorted_offsets[i-1], sorted_offsets[i])
+      note_time_map[sorted_offsets[i]] = time_counter
+    end
+    
+    return note_time_map
+  end
+end
+
+end