musicality 0.8.0 → 0.9.0

data/lib/musicality/performance/conversion/portamento_converter.rb

@@ -12,11 +12,14 @@ class PortamentoConverter
     end
   end
 
-  def self.portamento_elements(start_pitch, target_pitch, cents_per_step, duration, accented)
+  def self.portamento_elements(start_pitch, target_pitch, cents_per_step, duration, attack)
     pitches = portamento_pitches(start_pitch, target_pitch, cents_per_step)
     subdur = Rational(duration, pitches.size)
+    first = true
     pitches.map do |pitch|
-      SlurredElement.new(subdur, pitch, accented)
+      el = NoteSequence::Element.new(subdur, pitch, first ? attack : Attack::NONE)
+      first = false
+      el
     end
   end
 end

data/lib/musicality/performance/conversion/score_collator.rb

@@ -10,88 +10,96 @@ class ScoreCollator
       raise ScoreNotValidError, "errors found in score: #{score.errors}"
     end
     @score = score
+    @program = score.program.any? ? score.program : [0...score.duration]
   end
   
   def collate_parts
-    segments = @score.program
-    
     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 = Part.new(part.start_dynamic,
-	  dynamic_changes: new_dcs, notes: new_notes)
-	[ name, new_part ]
+        dyn_comp = ValueComputer.new(part.start_dynamic,part.dynamic_changes)
+
+        new_part = part.clone
+        new_part.notes = collate_notes(part.notes, @program)
+        new_part.start_dynamic, new_part.dynamic_changes = collate_changes(
+          part.start_dynamic, part.dynamic_changes, @program
+        )
+        [ name, new_part ]
       end
     ]
   end
   
   def collate_tempo_changes
-    collate_changes(@score.start_tempo,
-      @score.tempo_changes, @score.program)
+    collate_changes(@score.start_tempo, @score.tempo_changes, @program)
   end
   
   def collate_meter_changes
-    collate_changes(@score.start_meter,
-      @score.meter_changes, @score.program)
+    collate_changes(@score.start_meter, @score.meter_changes, @program)
   end
   
+  def collate_key_changes
+    collate_changes(@score.start_key, @score.key_changes, @program)
+  end
+
   private
   
   def collate_changes start_value, changes, program_segments
     new_changes = {}
-    comp = ValueComputer.new(start_value,changes)
+    comp = ValueComputer.new(start_value, changes)
     segment_start_offset = 0.to_r
     
-    program_segments.each do |seg|
+    new_start_val = comp.at(program_segments.first.first)
+    
+    program_segments.each_with_index do |seg, i|
       seg = seg.first...seg.last
       
-      # add segment start value
+      # add segment start value, but only if it's different than the value at 
+      # the end of the prev segment
       value = comp.at seg.first
-      new_changes[segment_start_offset] = Change::Immediate.new(value)
+      if i != 0 && comp.at(program_segments[i-1].last - 1e-5) != value
+        new_changes[segment_start_offset] = Change::Immediate.new(value)
+      end
       
       changes.each do |off,change|
-	adj_start_off = (off - seg.first) + segment_start_offset
-	
-	new_change = case change
-	when Change::Immediate
-	  change.clone if seg.include?(off)
-	when Change::Gradual::Trimmed
-	  end_off = off + change.remaining
-	  if off < seg.last && end_off > seg.first
-	    add_preceding = seg.first > off ? seg.first - off : 0
-	    add_trailing = end_off > seg.last ? end_off - seg.last : 0
+	       adj_start_off = (off - seg.first) + segment_start_offset
 
-	    if add_preceding == 0 && add_trailing == 0
-	      change.clone
-	    else
-	      adj_start_off += add_preceding
-	      change.untrim.trim(change.preceding + add_preceding,
-				 change.trailing + add_trailing)
-	    end
-	  end
-	when Change::Gradual
-	  end_off = off + change.duration
-	  if off < seg.last && end_off > seg.first
-	    preceding = seg.first > off ? seg.first - off : 0
-	    trailing = end_off > seg.last ? end_off - seg.last : 0
-	    if preceding == 0 && trailing == 0
-	      change.clone
-	    else
-	      adj_start_off += preceding
-	      change.trim(preceding, trailing)
-	    end
-	  end
-	end
-	
-	unless new_change.nil?
-	  new_changes[adj_start_off] = new_change
-	end
+      	new_change = case change
+      	when Change::Immediate
+      	  change.clone if seg.include?(off)
+      	when Change::Gradual::Trimmed
+      	  end_off = off + change.remaining
+      	  if off < seg.last && end_off > seg.first
+      	    add_preceding = seg.first > off ? seg.first - off : 0
+      	    add_trailing = end_off > seg.last ? end_off - seg.last : 0
+
+      	    if add_preceding == 0 && add_trailing == 0
+      	      change.clone
+      	    else
+      	      adj_start_off += add_preceding
+      	      change.untrim.trim(change.preceding + add_preceding,
+      				 change.trailing + add_trailing)
+      	    end
+      	  end
+      	when Change::Gradual
+      	  end_off = off + change.duration
+      	  if off < seg.last && end_off > seg.first
+      	    preceding = seg.first > off ? seg.first - off : 0
+      	    trailing = end_off > seg.last ? end_off - seg.last : 0
+      	    if preceding == 0 && trailing == 0
+      	      change.clone
+      	    else
+      	      adj_start_off += preceding
+      	      change.trim(preceding, trailing)
+      	    end
+      	  end
+      	end
+      	
+      	unless new_change.nil?
+      	  new_changes[adj_start_off] = new_change
+      	end
       end
     end
     
-    return new_changes
+    return new_start_val, new_changes
   end
   
   def collate_notes notes, program_segments
@@ -100,10 +108,10 @@ class ScoreCollator
       cur_offset = 0
       cur_notes = []
       
-      l = 0
-      while cur_offset < seg.first && l < notes.size
-        cur_offset += notes[l].duration
-        l += 1
+      i = 0
+      while cur_offset < seg.first && i < notes.size
+        cur_offset += notes[i].duration
+        i += 1
       end
       
       pre_remainder = cur_offset - seg.first
@@ -112,17 +120,15 @@ class ScoreCollator
       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
+      if i < notes.size
+        while cur_offset < seg.last && i < notes.size
+          cur_notes << notes[i].clone
+          cur_offset += notes[i].duration
+          i += 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_notes.last.duration = cur_notes.last.duration - overshoot
           cur_offset = seg.last
         end
       end

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

@@ -6,9 +6,9 @@ class MidiEvent
   end
   
   class NoteOn < MidiEvent
-    attr_reader :notenum, :accented
-    def initialize notenum, accented
-      @notenum, @accented = notenum, accented
+    attr_reader :notenum, :attack
+    def initialize notenum, attack
+      @notenum, @attack = notenum, attack
     end
   end
   

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

@@ -0,0 +1,127 @@
+module Musicality
+
+class MidiSettings
+  include Packable
+
+  attr_reader :program
+
+  def initialize program
+    @program = program
+  end
+
+  ACOUSTIC_GRAND_PIANO = MidiSettings.new(1)
+  BRIGHT_ACOUSTIC_PIANO = MidiSettings.new(2)
+  ELECTRIC_GRAND_PIANO = MidiSettings.new(3)
+  HONKY_TONK_PIANO = MidiSettings.new(4)
+  ELECTRIC_PIANO_1 = MidiSettings.new(5)
+  ELECTRIC_PIANO_2 = MidiSettings.new(6)
+  HARPSICHORD = MidiSettings.new(7)
+  CLAVINET = MidiSettings.new(8)
+  CELESTA = MidiSettings.new(9)
+
+  GLOCKENSPIEL = MidiSettings.new(10)
+  MUSIC_BOX = MidiSettings.new(11)
+  VIBRAPHONE = MidiSettings.new(12)
+  MARIMBA = MidiSettings.new(13)
+  XYLOPHONE = MidiSettings.new(14)
+  TUBULAR_BELLS = MidiSettings.new(15)
+  DULCIMER = MidiSettings.new(16)
+
+  DRAWBAR_ORGAN = MidiSettings.new(17)
+  PERCUSSIVE_ORGAN = MidiSettings.new(18)
+  ROCK_ORGAN = MidiSettings.new(19)
+  CHURCH_ORGAN = MidiSettings.new(20)
+  REED_ORGAN = MidiSettings.new(21)
+  ACCORDIAN = MidiSettings.new(22)
+  HARMONICA = MidiSettings.new(23)
+  TANGO_ACCORDIAN = MidiSettings.new(24)
+
+  ACOUSTIC_GUITAR_NYLON = MidiSettings.new(25)
+  ACOUSTIC_GUITAR_STEEL = MidiSettings.new(26)
+  ELECTRIC_GUITAR_JAZZ = MidiSettings.new(27)
+  ELECTRIC_GUITAR_CLEAN = MidiSettings.new(28)
+  ELECTRIC_GUITAR_MUTED = MidiSettings.new(29)
+  OVERDRIVEN_GUITAR = MidiSettings.new(30)
+  DISTORTION_GUITAR = MidiSettings.new(31)
+  GUITAR_HARMONICS = MidiSettings.new(32)
+  
+  ACOUSTIC_BASS = MidiSettings.new(33)
+  ELECTRIC_BASS_FINGER = MidiSettings.new(34)
+  ELECTRIC_BASS_PICK = MidiSettings.new(35)
+  FRETLESS_BASS = MidiSettings.new(36)
+  SLAP_BASS_1 = MidiSettings.new(37)
+  SLAP_BASS_2 = MidiSettings.new(38)
+  SYNTH_BASS_1 = MidiSettings.new(39)
+  SYNTH_BASS_2 = MidiSettings.new(40)
+
+  VIOLIN = MidiSettings.new(41)
+  VIOLA = MidiSettings.new(42)
+  CELLO = MidiSettings.new(43)
+  CONTRABASS = MidiSettings.new(44)
+  TREMOLO_STRINGS = MidiSettings.new(45)
+  PIZZICATO_STRINGS = MidiSettings.new(46)
+  ORCHESTRAL_HARP = MidiSettings.new(47)
+  TIMPANI = MidiSettings.new(48)
+  STRING_ENSEMBLE_1 = MidiSettings.new(49)
+  STRING_ENSEMBLE_2 = MidiSettings.new(50)
+  SYNTH_STRINGS_1 = MidiSettings.new(51)
+  SYNTH_STRINGS_2 = MidiSettings.new(52)
+  
+  CHOIR_AAHS = MidiSettings.new(53)
+  VOICE_OOHS = MidiSettings.new(54)
+  SYNTH_VOICE = MidiSettings.new(55)
+  ORCHESTRA_HIT = MidiSettings.new(56)
+  
+  TRUMPET = MidiSettings.new(57)
+  TROMBONE = MidiSettings.new(58)
+  TUBA = MidiSettings.new(59)
+  MUTED_TRUMPET = MidiSettings.new(60)
+  FRENCH_HORN = MidiSettings.new(61)
+  BRASS_SECTION = MidiSettings.new(62)
+  SYNTH_BRASS_1 = MidiSettings.new(63)
+  SYNTH_BRASS_2 = MidiSettings.new(64)
+  
+  SOPRANO_SAX = MidiSettings.new(65)
+  ALTO_SAX = MidiSettings.new(66)
+  TENOR_SAX = MidiSettings.new(67)
+  BARITONE_SAX = MidiSettings.new(68)
+  OBOE = MidiSettings.new(69)
+  ENGLISH_HORN = MidiSettings.new(70)
+  BASSOON = MidiSettings.new(71)
+  CLARINET = MidiSettings.new(72)
+  
+  PICCOLO = MidiSettings.new(73)
+  FLUTE = MidiSettings.new(74)
+  RECORDER = MidiSettings.new(75)
+  PAN_FLUTE = MidiSettings.new(76)
+  BLOWN_BOTTLE = MidiSettings.new(77)
+  SHAKUHACHI = MidiSettings.new(78)
+  WHISTLE = MidiSettings.new(79)
+  OCARINA = MidiSettings.new(80)
+  
+  LEAD_SQUARE = MidiSettings.new(81)
+  LEAD_SAWTOOTH = MidiSettings.new(82)
+  LEAD_CALLIOPE = MidiSettings.new(83)
+  LEAD_CHIFF = MidiSettings.new(84)
+  LEAD_CHARANG = MidiSettings.new(85)
+  LEAD_VOICE = MidiSettings.new(86)
+  LEAD_FIFTHS = MidiSettings.new(87)
+  LEAD_PLUS_BASS = MidiSettings.new(88)
+  
+  PAD_NEW_AGE = MidiSettings.new(89)
+  PAD_WARM = MidiSettings.new(90)
+  PAD_POLYSYNTH = MidiSettings.new(91)
+  PAD_CHOIR = MidiSettings.new(92)
+  PAD_BOWED = MidiSettings.new(93)
+  PAD_METALLIC = MidiSettings.new(94)
+  PAD_HALO = MidiSettings.new(95)
+  PAD_SWEEP = MidiSettings.new(96)
+end
+
+class Part
+  def midi_settings
+    find_settings(MidiSettings)
+  end
+end
+
+end

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

@@ -30,8 +30,14 @@ class MidiUtil
     (dynamic * 127).round
   end
   
-  def self.note_velocity(accented)
-    accented ? 112 : 70
+  def self.note_velocity(attack)
+    case attack
+    when Attack::NORMAL, Attack::NONE then 70
+    when Attack::TENUTO then 90
+    when Attack::ACCENT then 112
+    else
+      raise ArgumentError
+    end
   end
 end
 

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

@@ -2,10 +2,11 @@ module Musicality
 
 class PartSequencer
   def initialize part, dynamics_sample_rate: 50, cents_per_step: 10
-    replace_portamento_with_glissando(part.notes)
+    notes = part.notes.map {|n| n.clone }
+    replace_portamento_with_glissando(notes)
     
-    extractor = NoteSequenceExtractor.new(part.notes, cents_per_step)
-    note_sequences = extractor.extract_sequences
+    extractor = NoteSequenceExtractor.new(notes)
+    note_sequences = extractor.extract_sequences(cents_per_step)
     note_events = gather_note_events(note_sequences)
     
     dynamic_events = gather_dynamic_events(part.start_dynamic,
@@ -27,7 +28,7 @@ class PartSequencer
       
       track.events << case event
       when MidiEvent::NoteOn
-        vel = MidiUtil.note_velocity(event.accented)
+        vel = MidiUtil.note_velocity(event.attack)
         MIDI::NoteOn.new(channel, event.notenum, vel, delta)
       when MidiEvent::NoteOff
         MIDI::NoteOff.new(channel, event.notenum, 127, delta)
@@ -55,20 +56,17 @@ class PartSequencer
   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
+      offsets, elements = note_seq.offsets, note_seq.elements
+
+      elements.each_index do |i|
+        offset, element = offsets[i], elements[i]
+        pitch, attack = element.pitch, element.attack
         
         note_num = MidiUtil.pitch_to_notenum(pitch)
         on_at = offset
-        off_at = (i < (pitches.size - 1)) ? pitches[i+1][0] : note_seq.stop
+        off_at = (i < (offsets.size - 1)) ? offsets[i+1] : note_seq.stop
         
-        note_events.push [on_at, MidiEvent::NoteOn.new(note_num, accented)]
+        note_events.push [on_at, MidiEvent::NoteOn.new(note_num, attack)]
         note_events.push [off_at, MidiEvent::NoteOff.new(note_num)]
       end
     end
@@ -99,19 +97,22 @@ class PartSequencer
     return dynamic_events
   end
 
-  def begin_track midi_sequence, part_name, channel, program
+  def begin_track midi_sequence, track_name, channel, program
+    raise ArgumentError, "Program number #{program} is not in range 1-128" unless program.between?(1,128)
+    program_idx = program - 1 # program numbers start at 1, array indices start at 0
+
     # 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]
+    track.name = track_name
+    track.instrument = MIDI::GM_PATCH_NAMES[program_idx]
     
     # 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)
+    track.events << MIDI::ProgramChange.new(channel, program_idx)
     
     return track
   end

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

@@ -4,11 +4,18 @@ 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."
+      Convert it first using ScoreConverter."
     end
     
     @parts = score.collated? ? score.parts : ScoreCollator.new(score).collate_parts
-    
+
+    # parts should all have MIDI settings, defaults if necessary
+    @parts.each do |part_name, part|
+      unless part.midi_settings
+        part.settings.push MidiSettings.new(1)
+      end
+    end
+
     # 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.
@@ -17,7 +24,7 @@ class ScoreSequencer
   
   USEC_PER_QUARTER_SEC = 250000
   
-  def make_midi_seq instr_map = {}
+  def make_midi_seq selected_parts = @parts.keys
     seq = MIDI::Sequence.new()
     
     # first track for the sequence holds time sig and tempo events
@@ -27,12 +34,9 @@ class ScoreSequencer
     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
-      
+    selected_parts.each do |part_name|
+      part = @parts.fetch(part_name)
+      program = part.midi_settings.program
       pseq = PartSequencer.new(part)
       seq.tracks << pseq.make_midi_track(seq, part_name, channel, seq.ppqn, program)
       channel += 1