musicality 0.1.0

data/lib/musicality/performance/midi/part_sequencer.rb

@@ -0,0 +1,123 @@
+module Musicality
+
+class PartSequencer
+  def initialize part, dynamics_sample_rate: 50, cents_per_step: 10
+    replace_portamento_with_glissando(part.notes)
+    
+    extractor = NoteSequenceExtractor.new(part.notes, cents_per_step)
+    note_sequences = extractor.extract_sequences
+    note_events = gather_note_events(note_sequences)
+    
+    dynamic_events = gather_dynamic_events(part.start_dynamic,
+      part.dynamic_changes, dynamics_sample_rate)
+    
+    @events = (note_events + dynamic_events).sort
+  end
+  
+  def make_midi_track midi_sequence, part_name, channel, ppqn, program
+    track = begin_track(midi_sequence, part_name, channel, program)
+    
+    prev_offset = 0
+    @events.each do |offset, event|
+      if offset == prev_offset
+        delta = 0
+      else
+        delta = MidiUtil.delta(offset - prev_offset, ppqn)
+      end
+      
+      track.events << case event
+      when MidiEvent::NoteOn
+        vel = MidiUtil.note_velocity(event.accented)
+        MIDI::NoteOn.new(channel, event.notenum, vel, delta)
+      when MidiEvent::NoteOff
+        MIDI::NoteOff.new(channel, event.notenum, 127, delta)
+      when MidiEvent::Expression
+        MIDI::Controller.new(channel, MIDI::CC_EXPRESSION_CONTROLLER, event.volume, delta)
+      end
+      
+      prev_offset = offset
+    end
+   return track
+  end
+  
+  private
+  
+  def replace_portamento_with_glissando notes
+    notes.each do |note|
+      note.links.each do |pitch,link|
+        if link.is_a? Link::Portamento
+          note.links[pitch] = Link::Glissando.new(link.target_pitch)
+        end
+      end
+    end
+  end
+  
+  def gather_note_events note_sequences
+    note_events = []
+    note_sequences.each do |note_seq|
+      pitches = note_seq.pitches.sort
+      pitches.each_index do |i|
+        offset, pitch = pitches[i]
+        
+        accented = false
+        if note_seq.attacks.has_key?(offset)
+          accented = note_seq.attacks[offset].accented?
+        end
+        
+        note_num = MidiUtil.pitch_to_notenum(pitch)
+        on_at = offset
+        off_at = (i < (pitches.size - 1)) ? pitches[i+1][0] : note_seq.stop
+        
+        note_events.push [on_at, MidiEvent::NoteOn.new(note_num, accented)]
+        note_events.push [off_at, MidiEvent::NoteOff.new(note_num)]
+      end
+    end
+    return note_events
+  end
+  
+  def gather_dynamic_events start_dyn, dyn_changes, sample_rate
+    dynamic_events = []
+    
+    dyn_comp = ValueComputer.new(start_dyn,dyn_changes)
+    finish = 0
+    if dyn_changes.any?
+      finish, change = dyn_changes.max
+      if change.is_a? Change::Gradual
+        finish += change.duration
+      end
+    end
+    samples = dyn_comp.sample(0, finish, sample_rate)
+    
+    prev = nil
+    samples.each_index do |i|
+      sample = samples[i]
+      unless sample == prev
+        offset = Rational(i,sample_rate)
+        volume = MidiUtil.dynamic_to_volume(sample)
+        dynamic_events.push [offset, MidiEvent::Expression.new(volume)]
+      end
+      prev = sample
+    end
+    
+    return dynamic_events
+  end
+
+  def begin_track midi_sequence, part_name, channel, program
+    # Track to hold part notes
+    track = MIDI::Track.new(midi_sequence)
+    
+    # Name the track and instrument
+    track.name = part_name
+    track.instrument = MIDI::GM_PATCH_NAMES[program]
+    
+    # Add a volume controller event (optional).
+    track.events << MIDI::Controller.new(channel, MIDI::CC_VOLUME, 127)
+    
+    # Change to particular instrument sound
+    track.events << MIDI::ProgramChange.new(channel, program)
+    
+    return track
+  end
+end
+
+end

data/lib/musicality/performance/midi/score_sequencer.rb

@@ -0,0 +1,45 @@
+module Musicality
+
+class ScoreSequencer
+  def initialize score
+    unless score.is_a?(Score::Timed)
+      raise ArgumentError, "The given score is not a Score::Timed. \
+      Convert it first using MeasureScoreConverter or UnmeasuredScoreConverter."
+    end
+    
+    @parts = score.collated? ? score.parts : ScoreCollator.new(score).collate_parts
+    
+    # part names should all be strings, because 1) a midi track name needs to
+    # be a string and 2) the instrument map used to map part names to MIDI
+    # program numbers will use part name strings as keys.
+    @parts = Hash[ @parts.map {|k,v| [k.to_s,v] } ]
+  end
+  
+  USEC_PER_QUARTER_SEC = 250000
+  
+  def make_midi_seq instr_map = {}
+    seq = MIDI::Sequence.new()
+    
+    # first track for the sequence holds time sig and tempo events
+    track0 = MIDI::Track.new(seq)
+    seq.tracks << track0
+    track0.events << MIDI::Tempo.new(USEC_PER_QUARTER_SEC)
+    track0.events << MIDI::MetaEvent.new(MIDI::META_SEQ_NAME, 'Sequence Name')
+    
+    channel = 0
+    @parts.each do |part_name,part|
+      program = 1
+      if instr_map.has_key?(part_name)
+        program = instr_map[part_name]
+      end
+      
+      pseq = PartSequencer.new(part)
+      seq.tracks << pseq.make_midi_track(seq, part_name, channel, seq.ppqn, program)
+      channel += 1
+    end
+    
+    return seq
+  end
+end
+
+end

data/lib/musicality/performance/model/note_attacks.rb

@@ -0,0 +1,19 @@
+module Musicality
+
+require 'singleton'
+class AccentedAttack
+  include Singleton
+  
+  def accented?; return true; end
+end
+
+class UnaccentedAttack
+  include Singleton
+  
+  def accented?; return false; end
+end
+
+ACCENTED = AccentedAttack.instance
+UNACCENTED = UnaccentedAttack.instance
+
+end

data/lib/musicality/performance/model/note_sequence.rb

@@ -0,0 +1,111 @@
+module Musicality
+
+SlurredElement = Struct.new(:duration, :pitch, :accented) do
+  def slurred?; true; end
+  def articulation; Articulations::NORMAL; end
+  def accented?; accented; end
+end
+
+LegatoElement = Struct.new(:duration, :pitch, :accented) do
+  def slurred?; false; end
+  def articulation; Articulations::NORMAL; end
+  def accented?; accented; end
+end
+
+FinalElement = Struct.new(:duration, :pitch, :accented, :articulation) do
+  def slurred?; false; end
+  def accented?; accented; end
+end
+
+class NoteSequence
+  def self.adjust_duration duration, articulation
+    x = duration
+    y = Math.log2(x)
+
+    case articulation
+    when Articulations::TENUTO
+      x
+    when Articulations::PORTATO
+      x / (1 + 2**(y-1))
+    when Articulations::STACCATO
+      x / (1 + 2**(y))
+    when Articulations::STACCATISSIMO
+      x / (1 + 2**(y+1))
+    else
+      x - (1/16.0)*(1/(1+2**(-y)))
+    end
+  end
+
+  attr_reader :start, :stop, :pitches, :attacks
+  def initialize start, stop, pitches, attacks
+    if start >= stop
+      raise ArgumentError, "start #{start} is not less than stop #{stop}"
+    end
+    
+    if pitches.empty?
+      raise ArgumentError, "no pitches given (at least one pitch is required at start offset)"
+    end
+    
+    unless pitches.has_key?(start)
+      raise ArgumentError, "no start pitch given"
+    end
+    
+    pitches.keys.each do |offset|
+      unless offset.between?(start,stop)
+        raise ArgumentError, "pitch offset #{offset} is not between start #{start} and stop #{stop}"
+      end
+    end
+    
+    if attacks.empty?
+      raise ArgumentError, "no attacks given (at least one is required at start offset)"
+    end
+    
+    unless attacks.has_key?(start)
+      raise ArgumentError, "no start attack given"
+    end
+    
+    attacks.keys.each do |offset|
+      unless offset.between?(start,stop)
+        raise ArgumentError, "attack offset #{offset} is not between start #{start} and stop #{stop}"
+      end
+    end
+    
+    @start, @stop = start, stop
+    @pitches, @attacks = pitches, attacks
+  end
+    
+  def self.from_elements offset, elements
+    pitches = {}
+    attacks = {}
+    start = offset
+    
+    if elements.empty?
+      raise ArgumentError, "no elements given"
+    end
+      
+    last = elements.last
+    skip_attack = false
+    elements.each do |el|
+      if skip_attack
+        unless pitches.max[1] == el.pitch
+          pitches[offset] = el.pitch
+        end
+      else
+        pitches[offset] = el.pitch
+        attacks[offset] = el.accented ? ACCENTED : UNACCENTED        
+      end      
+      skip_attack = el.slurred?
+      
+      unless el.equal?(last)
+        offset += el.duration
+      end
+    end
+    stop = offset + NoteSequence.adjust_duration(last.duration, last.articulation)
+    
+    new(start, stop, pitches, attacks)
+  end
+
+  def duration; @stop - @start; end
+end
+
+end

data/lib/musicality/performance/util/note_linker.rb

@@ -0,0 +1,28 @@
+module Musicality
+
+class NoteLinker
+  def self.find_unlinked_pitches note
+    linked = Set.new(note.pitches) & note.links.keys
+    (Set.new(note.pitches) - linked).to_a
+  end
+  
+  def self.find_untargeted_pitches note, next_note
+    linked = Set.new(note.pitches) & note.links.keys
+    targeted = Set.new(linked.map {|p| note.links[p].target_pitch })
+    (Set.new(next_note.pitches) - targeted).to_a
+  end
+  
+  def self.figure_links note, next_note
+    unlinked = find_unlinked_pitches(note)
+    untargeted = find_untargeted_pitches(note, next_note)
+    Optimization.linking(unlinked, untargeted)
+  end
+  
+  def self.fully_link note, next_note, link_class
+    figure_links(note,next_note).each do |pitch,tgt_pitch|
+      note.links[pitch] = link_class.new(tgt_pitch)
+    end
+  end  
+end
+
+end

data/lib/musicality/performance/util/optimization.rb

@@ -0,0 +1,31 @@
+module Musicality
+
+module Optimization
+  def self.linking unlinked, untargeted
+    n = [unlinked.size, untargeted.size].min
+    
+    bestsol = nil
+    bestscore = Float::INFINITY
+    unlinked.combination(n).each do |comb|
+      untargeted.permutation(n).each do |perm|
+        score = 0
+        n.times do |i|
+          score += perm[i].diff(comb[i]).abs
+        end
+        
+        if score < bestscore
+          bestsol = [ comb, perm ]
+          bestscore = score
+        end
+      end
+    end
+    
+    solution = {}
+    n.times do |i|
+      solution[ bestsol[0][i] ] = bestsol[1][i]
+    end
+    return solution
+  end
+end
+
+end

data/lib/musicality/validatable.rb

@@ -0,0 +1,38 @@
+# assumes that @checks is defined as an array of no-arg lambdas, each
+# lambda raising an error (with useful msg) when check fails
+module Validatable
+  attr_reader :errors
+  
+  def check_methods; []; end
+  def validatables; []; end
+  
+  def validate
+    @errors = []
+    
+    
+    check_methods.each do |check_method|
+      begin
+        send(check_method)
+      rescue StandardError => e
+        @errors.push e
+      end
+    end
+    
+    validatables.each do |v|
+      if v.respond_to?(:validate)
+        @errors += v.validate
+      end
+    end
+    
+    return @errors
+  end
+  
+  def valid?
+    self.validate
+    @errors.empty?
+  end
+  
+  def invalid?
+    !self.valid?
+  end
+end

data/lib/musicality/version.rb

@@ -0,0 +1,3 @@
+module Musicality
+  VERSION = "0.1.0"
+end

data/lib/musicality.rb

@@ -0,0 +1,81 @@
+# basic core classes
+require 'musicality/version'
+require 'musicality/validatable'
+require 'musicality/errors'
+
+#
+# Notation
+#
+
+require 'musicality/notation/model/pitch'
+require 'musicality/notation/model/pitches'
+require 'musicality/notation/model/link'
+require 'musicality/notation/model/articulations'
+require 'musicality/notation/model/note'
+require 'musicality/notation/model/dynamics'
+require 'musicality/notation/model/change'
+require 'musicality/notation/model/part'
+require 'musicality/notation/model/program'
+require 'musicality/notation/model/meter'
+require 'musicality/notation/model/meters'
+require 'musicality/notation/model/score'
+
+require 'treetop'
+require 'musicality/notation/parsing/numbers/nonnegative_integer_parsing'
+require 'musicality/notation/parsing/numbers/positive_integer_parsing'
+require 'musicality/notation/parsing/numbers/positive_float_parsing'
+require 'musicality/notation/parsing/numbers/positive_rational_parsing'
+require 'musicality/notation/parsing/numbers/nonnegative_float_parsing'
+require 'musicality/notation/parsing/numbers/nonnegative_rational_parsing'
+require 'musicality/notation/parsing/pitch_parsing'
+require 'musicality/notation/parsing/pitch_node'
+require 'musicality/notation/parsing/duration_parsing'
+require 'musicality/notation/parsing/duration_nodes'
+require 'musicality/notation/parsing/articulation_parsing'
+require 'musicality/notation/parsing/link_parsing'
+require 'musicality/notation/parsing/link_nodes'
+require 'musicality/notation/parsing/note_parsing'
+require 'musicality/notation/parsing/note_node'
+require 'musicality/notation/parsing/meter_parsing'
+require 'musicality/notation/parsing/segment_parsing'
+require 'musicality/notation/parsing/parseable'
+require 'musicality/notation/parsing/convenience_methods'
+
+require 'musicality/notation/packing/change_packing'
+require 'musicality/notation/packing/part_packing'
+require 'musicality/notation/packing/program_packing'
+require 'musicality/notation/packing/score_packing'
+
+require 'musicality/notation/util/interpolation'
+require 'musicality/notation/util/piecewise_function'
+require 'musicality/notation/util/value_computer'
+
+require 'musicality/notation/conversion/tempo_conversion'
+require 'musicality/notation/conversion/change_conversion'
+require 'musicality/notation/conversion/note_time_converter'
+require 'musicality/notation/conversion/unmeasured_score_converter'
+require 'musicality/notation/conversion/unmeasured_score_conversion'
+require 'musicality/notation/conversion/measure_note_map'
+require 'musicality/notation/conversion/measured_score_converter'
+require 'musicality/notation/conversion/measured_score_conversion'
+
+#
+# Performance
+#
+
+require 'musicality/performance/model/note_attacks'
+require 'musicality/performance/model/note_sequence'
+
+require 'musicality/performance/util/optimization'
+require 'musicality/performance/util/note_linker'
+
+require 'musicality/performance/conversion/glissando_converter'
+require 'musicality/performance/conversion/portamento_converter'
+require 'musicality/performance/conversion/note_sequence_extractor'
+require 'musicality/performance/conversion/score_collator'
+
+require 'midilib'
+require 'musicality/performance/midi/midi_util'
+require 'musicality/performance/midi/midi_events'
+require 'musicality/performance/midi/part_sequencer'
+require 'musicality/performance/midi/score_sequencer'

data/musicality.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'musicality/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "musicality"
+  spec.version       = Musicality::VERSION
+  spec.authors       = ["James Tunnell"]
+  spec.email         = ["jamestunnell@gmail.com"]
+  spec.summary       = %q{Music notation, composition, and performance}
+  spec.description   = %q{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. }
+  spec.homepage      = "https://github.com/jamestunnell/musicality"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 2.9"
+  
+  spec.add_dependency "treetop", "~> 1.5"
+  spec.add_dependency 'midilib', '~> 2.0'
+  spec.add_dependency 'docopt', '~> 0.5'
+end

data/spec/musicality_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Musicality do
+  it "should have a VERSION constant" do
+    subject.const_get('VERSION').should_not be_empty
+  end
+end

data/spec/notation/conversion/change_conversion_spec.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Change::Immediate do
+  describe '#offsets' do
+    it 'should return array with just the given base offset' do
+      c = Change::Immediate.new(12)
+      c.offsets(44).should eq([44])
+    end
+  end
+end
+
+describe Change::Gradual do
+  describe '#offsets' do
+    before :all do
+      @change = Change::Gradual.new(100,1.5,0.5,0.25)
+      @base = 25.5
+      @offsets = @change.offsets(@base)
+    end
+    
+    it 'should return array with 4 elements' do
+      @offsets.size.should eq(4)
+    end
+    
+    it 'should include the given base offset' do
+      @offsets.should include(@base)
+    end
+    
+    it 'should include the base offset - elapsed' do
+      @offsets.should include(@base - @change.elapsed)
+    end
+    
+    it 'should include the base offset + impending' do
+      @offsets.should include(@base + @change.impending)
+    end
+    
+    it 'should include the base offset + impending + remaining' do
+      @offsets.should include(@base + @change.impending + @change.remaining)
+    end
+  end
+end

data/spec/notation/conversion/measure_note_map_spec.rb

@@ -0,0 +1,73 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe 'Conversion.measure_note_map' do
+  before :all do
+    mdurs = Hash[ [[0, (3/4)], [1, (1/2)], [3, (3/4)]] ]
+    @moffs = [ 0, 1, 3, 4, 5, 6, 7, 8, 11, 14, 17, 20, (45/2)]
+    @mnoff_map = Conversion.measure_note_map(@moffs,mdurs)
+  end
+  
+  it 'should return a Hash' do
+    @mnoff_map.should be_a Hash
+  end
+  
+  it 'should have same size as array returned by #measure_offsets' do
+    @mnoff_map.size.should eq(@moffs.size)
+  end
+  
+  it 'should have a key for each offset in the array returned by #measure_offsets' do
+    @mnoff_map.keys.sort.should eq(@moffs)
+  end
+  
+  context 'single measure duration at 0' do
+    it 'should mutiply all measure offsets by start measure duration' do
+      [TWO_FOUR,SIX_EIGHT,FOUR_FOUR,THREE_FOUR].each do |meter|
+        mdur = meter.measure_duration
+        mdurs = { 0 => mdur }
+        tgt = @moffs.map {|moff| moff * mdur}
+        Conversion.measure_note_map(@moffs,mdurs).values.sort.should eq(tgt)
+      end
+    end
+  end
+  
+  context '1 meter change' do
+    before :all do
+      @first_mc_off = 3
+      @start_meter = THREE_FOUR
+      @new_meter = TWO_FOUR
+      @score = Score::Measured.new(@start_meter, 120,
+        meter_changes: { @first_mc_off => Change::Immediate.new(@new_meter) },
+        tempo_changes: {
+          "1/2".to_r => Change::Gradual.new(100,1),
+          2 => Change::Immediate.new(120),
+          3 => Change::Immediate.new(100),
+          3.1 => Change::Gradual.new(100,1),
+          5 => Change::Immediate.new(120),
+          6 => Change::Immediate.new(100),
+        }
+      )
+      @moffs = @score.measure_offsets
+      @mdurs = @score.measure_durations
+      @mnoff_map = Conversion.measure_note_map(@moffs,@mdurs)
+    end
+    
+    it 'should mutiply all measure offsets that occur on or before 1st meter change offset by start measure duration' do
+      moffs = @moffs.select{ |x| x <= @first_mc_off }
+      tgt = moffs.map do |moff|
+        moff * @start_meter.measure_duration
+      end.sort
+      src = @mnoff_map.select {|k,v| k <= @first_mc_off }
+      src.values.sort.should eq(tgt)
+    end
+    
+    it 'should, for any measure offsets occurring after 1st meter change offset, add 1st_meter_change_offset * 1st_measure_duration to \
+        new_measure_duration * (offset - 1st_meter_change_offset)' do
+      moffs = @moffs.select{ |x| x > @first_mc_off }
+      tgt = moffs.map do |moff|
+        @first_mc_off * @start_meter.measure_duration + (moff - @first_mc_off) * @new_meter.measure_duration
+      end.sort
+      src = @mnoff_map.select {|k,v| k > @first_mc_off }
+      src.values.sort.should eq(tgt)
+    end
+  end
+end