music-performance 0.2.1

data/lib/music-performance/conversion/note_sequence_extractor.rb

@@ -0,0 +1,100 @@
+module Music
+module Performance
+
+class NoteSequenceExtractor
+  # For all link types:
+  #  - Remove link where source pitch is not in current note
+  # For tie:
+  #  - Remove any bad tie (where the tying pitch does not exist in the next note).
+  #  - Replace any good tie with a slur.
+  # For slur/legato:
+  #  - Remove any bad link (where the target pitch does not exist in the next note).
+  # TODO: what to do about multiple links that target the same pitch?
+  def self.fixup_links note, next_note
+    note.links.each do |pitch, link|
+      if !note.pitches.include?(pitch)
+        note.links.delete pitch
+      elsif link.is_a? Music::Transcription::Link::Tie
+        if next_note.pitches.include? pitch
+          note.links[pitch] = Music::Transcription::Link::Slur.new(pitch)
+        else
+          note.links.delete pitch
+        end
+      elsif (link.is_a?(Music::Transcription::Link::Slur) ||
+             link.is_a?(Music::Transcription::Link::Legato))
+        unless next_note.pitches.include? link.target_pitch
+          note.links.delete pitch
+        end
+      end
+    end
+  end
+
+  def self.replace_articulation note, next_note
+    case note.articulation
+    when Music::Transcription::Articulations::SLUR
+      NoteLinker.fully_link(note, next_note, Music::Transcription::Link::Slur)
+      note.articulation = Music::Transcription::Articulations::NORMAL
+    when Music::Transcription::Articulations::LEGATO
+      NoteLinker.fully_link(note, next_note, Music::Transcription::Link::Legato)
+      note.articulation = Music::Transcription::Articulations::NORMAL
+    end
+  end
+
+  attr_reader :notes
+  def initialize notes, cents_per_step = 10
+    @cents_per_step = cents_per_step
+    @notes = notes.map {|n| n.clone }
+
+    @notes.push Music::Transcription::Note.quarter
+    (@notes.size-1).times do |i|
+      NoteSequenceExtractor.fixup_links(@notes[i], @notes[i+1])
+      NoteSequenceExtractor.replace_articulation(@notes[i], @notes[i+1])
+    end
+    @notes.pop
+  end
+
+  def extract_sequences
+    sequences = []
+    offset = 0
+
+    @notes.each_index do |i|
+      while @notes[i].pitches.any?
+        elements = []
+
+        j = i
+        loop do
+          note = @notes[j]
+          pitch = note.pitches.pop
+          dur = note.duration
+          accented = note.accented
+          link = note.links[pitch]
+
+          case link
+          when Music::Transcription::Link::Slur
+            elements.push(SlurredElement.new(dur, pitch, accented))
+          when Music::Transcription::Link::Legato
+            elements.push(LegatoElement.new(dur, pitch, accented))
+          when Music::Transcription::Link::Glissando
+            elements += GlissandoConverter.glissando_elements(pitch, link.target_pitch, dur, accented)
+          when Music::Transcription::Link::Portamento
+            elements += PortamentoConverter.portamento_elements(pitch, link.target_pitch, @cents_per_step, dur, accented)
+          else
+            elements.push(FinalElement.new(dur, pitch, accented, note.articulation))
+            break
+          end
+
+          j += 1
+          break if j >= @notes.size || !@notes[j].pitches.include?(link.target_pitch)
+        end
+
+        sequences.push(NoteSequence.from_elements(offset,elements))
+      end
+      offset += @notes[i].duration
+    end
+
+    return sequences
+  end
+end
+
+end
+end

data/lib/music-performance/conversion/note_time_converter.rb

@@ -0,0 +1,76 @@
+module Music
+module Performance
+  
+# Convert note duration to time duration. 
+class NoteTimeConverter
+
+  def initialize tempo_computer, beat_duration_computer, sample_rate
+    @tempo_computer = tempo_computer
+    @beat_duration_computer = beat_duration_computer
+    @sample_period = Rational(1,sample_rate)
+  end
+  
+  def self.notes_per_second tempo, beat_duration
+    (tempo * beat_duration) * Rational(1,60)
+  end
+  
+  def notes_per_second_at offset
+    tempo = @tempo_computer.value_at offset
+    beat_duration = @beat_duration_computer.value_at offset
+    return NoteTimeConverter.notes_per_second(tempo,beat_duration)
+  end
+  
+  # Convert the given note duration to a time duration. Using the tempo computer
+  # and beat duration computer, figure the current notes-per-second relationship
+  # depending on the current note offset. Using this, note duration for each
+  # sample is known and accumulated as samples are taken. When accumulated note
+  # duration passes the given desired duration (note_end - note_begin), the
+  # number of samples take will indicated the corresponding time duration. There
+  # is adjustment for last sample taken, which likely goes past the desired note
+  # duration.
+  #
+  # @param [Numeric] note_begin the starting note offset.
+  # @param [Numeric] note_end the ending note offset.
+  # @raise [ArgumentError] if note end is less than note begin.
+  def time_elapsed note_begin, note_end
+    raise ArgumentError "note end is less than note begin" if note_end < note_begin
+    
+    time = 0.to_r
+    note = note_begin
+    
+    while note < note_end
+      notes_per_sec = notes_per_second_at note
+      notes_per_sample = notes_per_sec * @sample_period
+      
+      if (note + notes_per_sample) > note_end
+        #interpolate between note and note_end
+        perc = (note_end - note) / notes_per_sample
+        time += @sample_period * perc
+        note = note_end
+      else
+        time += @sample_period
+        note += notes_per_sample
+      end
+    end
+    
+    return time
+  end
+
+  #map absolute note offsets to relative time offsets
+  def map_note_offsets_to_time_offsets note_offsets
+    time_counter = 0.0
+    sorted_offsets = note_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
+end

data/lib/music-performance/conversion/portamento_converter.rb

@@ -0,0 +1,26 @@
+module Music
+module Performance
+
+class PortamentoConverter
+  def self.portamento_pitches(start_pitch, target_pitch, cents_per_step)
+    start, finish = start_pitch.total_cents, target_pitch.total_cents
+    step_size = finish >= start ? cents_per_step : -cents_per_step
+    nsteps = ((finish - 1 - start) / step_size.to_f).ceil
+    cents = Array.new(nsteps+1){|i| start + i * step_size }
+    
+    cents.map do |cent|
+      Music::Transcription::Pitch.new(cent: cent)
+    end
+  end
+
+  def self.portamento_elements(start_pitch, target_pitch, cents_per_step, duration, accented)
+    pitches = portamento_pitches(start_pitch, target_pitch, cents_per_step)
+    subdur = Rational(duration, pitches.size)
+    pitches.map do |pitch|
+      SlurredElement.new(subdur, pitch, accented)
+    end
+  end
+end
+
+end
+end

data/lib/music-performance/conversion/score_collator.rb

@@ -0,0 +1,121 @@
+module Music
+module Performance
+
+class ScoreNotValidError < StandardError; end
+
+# Combine multiple program segments to one, using tempo/note/dynamic
+# replication and truncation where necessary.
+class ScoreCollator
+  def initialize score
+    unless score.valid?
+      raise ScoreNotValidError, "errors found in score: #{score.errors}"
+    end
+    @score = score
+  end
+  
+  def collate_parts
+    segments = @score.program.segments
+    
+    Hash[
+      @score.parts.map do |name, part|
+	new_dcs = collate_changes(part.start_dynamic,
+	  part.dynamic_changes, segments)
+	new_notes = collate_notes(part.notes, segments)
+	new_part = Music::Transcription::Part.new(part.start_dynamic,
+	  dynamic_changes: new_dcs, notes: new_notes)
+	[ name, new_part ]
+      end
+    ]
+  end
+  
+  def collate_tempo_changes
+    collate_changes(@score.start_tempo,
+      @score.tempo_changes, @score.program.segments)
+  end
+  
+  def collate_meter_changes
+    collate_changes(@score.start_meter,
+      @score.meter_changes, @score.program.segments)
+  end
+  
+  private
+  
+  def collate_changes start_value, changes, program_segments
+    new_changes = {}
+    comp = ValueComputer.new(start_value,changes)
+    segment_start_offset = 0.to_r
+    
+    program_segments.each do |seg|
+      included = changes.select {|offset,change| offset > seg.first && offset < seg.last }
+      included.each do |offset, change|
+	if(offset + change.duration) > seg.last
+	  change.duration = seg.last - offset
+	  change.value = comp.value_at seg.last
+	end
+      end
+      
+      # find & add segment start value first
+      value = comp.value_at seg.first
+      offset = segment_start_offset
+      new_changes[offset] = Music::Transcription::Change::Immediate.new(value)
+      
+      # add changes to part, adjusting for segment start offset
+      included.each do |offset2, change|
+	offset3 = (offset2 - seg.first) + segment_start_offset
+	new_changes[offset3] = change
+      end
+      
+      segment_start_offset += (seg.last - seg.first)
+    end
+    
+    return new_changes
+  end
+  
+  def collate_notes notes, program_segments
+    new_notes = []
+    program_segments.each do |seg|
+      cur_offset = 0
+      cur_notes = []
+      
+      l = 0
+      while cur_offset < seg.first && l < notes.size
+        cur_offset += notes[l].duration
+        l += 1
+      end
+      
+      pre_remainder = cur_offset - seg.first
+      if pre_remainder > 0
+        cur_notes << Music::Transcription::Note.new(pre_remainder)
+      end
+      
+      # found some notes to add...
+      if l < notes.size
+        r = l
+        while cur_offset < seg.last && r < notes.size
+          cur_offset += notes[r].duration
+          r += 1
+        end
+        
+        cur_notes += Marshal.load(Marshal.dump(notes[l...r]))
+        overshoot = cur_offset - seg.last
+        if overshoot > 0
+          cur_notes[-1].duration -= overshoot
+          cur_offset = seg.last
+        end
+        
+        cur_notes[-1].links.clear
+      end
+      
+      post_remainder = seg.last - cur_offset
+      if post_remainder > 0
+        cur_notes << Music::Transcription::Note.new(post_remainder)
+      end
+        
+      new_notes.concat cur_notes
+    end
+    return new_notes
+  end
+end
+
+end
+end

data/lib/music-performance/conversion/score_time_converter.rb

@@ -0,0 +1,112 @@
+require 'set'
+
+module Music
+module Performance
+
+# Utility class to convert a score from note-based to time-based offsets
+class ScoreTimeConverter
+
+  def initialize score, sample_rate
+    tempo_computer = ValueComputer.new(
+      score.start_tempo, score.tempo_changes)
+    
+    bdcs = Hash[ score.meter_changes.map do |offset,change|
+      newchange = change.clone
+      newchange.value = change.value.beat_duration
+      [offset, newchange]
+    end ]
+    beat_duration_computer = ValueComputer.new(
+      score.start_meter.beat_duration, bdcs)
+    
+    @note_time_converter = NoteTimeConverter.new(
+      tempo_computer, beat_duration_computer, sample_rate)
+    @score = score
+    @note_time_map = make_note_time_map(gather_all_offsets)
+  end
+  
+  # Convert note-based offsets & durations to time-based.
+  def convert_parts
+    newparts = {}
+    @score.parts.each do |name,part|
+      offset = 0
+      
+      newnotes = part.notes.map do |note|
+        starttime = @note_time_map[offset]
+        endtime = @note_time_map[offset + note.duration]
+        offset += note.duration
+        newnote = note.clone
+        newnote.duration = endtime - starttime
+        newnote
+      end
+      
+      new_dcs = Hash[
+        part.dynamic_changes.map do |offset, change|
+          timeoffset = @note_time_map[offset]
+          newchange = change.clone
+          newchange.duration = @note_time_map[offset + change.duration]
+          
+          [timeoffset,newchange]
+        end
+      ]
+      
+      newparts[name] = Music::Transcription::Part.new(
+        part.start_dynamic,
+        notes: newnotes,
+        dynamic_changes: new_dcs
+      )
+    end
+    return newparts
+  end
+  
+  # Convert note-based offsets & durations to time-based.
+  def convert_program
+    newsegments = @score.program.segments.map do |segment|
+      first = @note_time_map[segment.first]
+      last = @note_time_map[segment.last]
+      first...last
+    end
+    Program.new(newsegments)
+  end
+  
+  private
+
+  def gather_all_offsets
+    note_offsets = Set.new [0]
+    
+    @score.parts.each do |name, part|
+      offset = 0.to_r
+      part.notes.each do |note|
+        offset += note.duration
+        note_offsets << offset
+      end
+      
+      part.dynamic_changes.each do |change_offset, change|
+        note_offsets << change_offset
+        note_offsets << (change_offset + change.duration)
+      end
+    end
+    
+    @score.program.segments.each do |segment|
+      note_offsets << segment.first
+      note_offsets << segment.last
+    end
+
+    return note_offsets
+  end
+  
+  def make_note_time_map note_offsets
+    return @note_time_converter.map_note_offsets_to_time_offsets note_offsets
+  end
+end
+
+end
+
+module Transcription
+  class Score
+    def to_time_score sample_rate
+      ScoreTimeConverter.new(self,sample_rate).make_time_score
+    end
+  end
+end
+
+end

data/lib/music-performance/model/note_attacks.rb

@@ -0,0 +1,21 @@
+module Music
+module Performance
+
+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
+end