musicality 0.11.1 → 0.12.0

data/lib/musicality/notation/parsing/numbers/nonnegative_integer_parsing.rb

@@ -51,6 +51,7 @@ module NonnegativeInteger
     else
       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
       r0.extend(NonnegativeInteger0)
+      r0.extend(NonnegativeInteger0)
     end
 
     node_cache[:nonnegative_integer][start_index] = r0

data/lib/musicality/notation/parsing/numbers/nonnegative_rational_parsing.rb

@@ -52,7 +52,7 @@ module NonnegativeRational
         r2 = true
         @index += match_len
       else
-        terminal_parse_failure("/")
+        terminal_parse_failure('"/"')
         r2 = nil
       end
       s0 << r2

data/lib/musicality/notation/parsing/numbers/positive_float_parsing.rb

@@ -36,18 +36,21 @@ module PositiveFloat
       r1 = SyntaxNode.new(input, (index-1)...index) if r1 == true
       r0 = r1
       r0.extend(PositiveFloat0)
+      r0.extend(PositiveFloat0)
     else
       r2 = _nt_float2
       if r2
         r2 = SyntaxNode.new(input, (index-1)...index) if r2 == true
         r0 = r2
         r0.extend(PositiveFloat0)
+        r0.extend(PositiveFloat0)
       else
         r3 = _nt_float3
         if r3
           r3 = SyntaxNode.new(input, (index-1)...index) if r3 == true
           r0 = r3
           r0.extend(PositiveFloat0)
+          r0.extend(PositiveFloat0)
         else
           @index = i0
           r0 = nil
@@ -436,7 +439,7 @@ module PositiveFloat
       r1 = true
       @index += match_len
     else
-      terminal_parse_failure("e")
+      terminal_parse_failure('"e"')
       r1 = nil
     end
     s0 << r1

data/lib/musicality/notation/parsing/numbers/positive_rational_parsing.rb

@@ -50,7 +50,7 @@ module PositiveRational
         r2 = true
         @index += match_len
       else
-        terminal_parse_failure("/")
+        terminal_parse_failure('"/"')
         r2 = nil
       end
       s0 << r2

data/lib/musicality/notation/parsing/parseable.rb

@@ -3,28 +3,24 @@ module Musicality
 # to use, include Parseable and define PARSER constant that has #parse method.
 module Parseable
   DEFAULT_SPLIT_PATTERN = " "
-  
+
   def self.included(base)
     base.extend(ClassMethods)
   end
-  
+
   module ClassMethods
-    def parser
-      self.const_get(:PARSER)
-    end
-    
-    def convert node
-      node.send(self.const_get(:CONVERSION_METHOD))
-    end
-    
     def parse str
-      convert(parser.parse(str))
+      parser = self.const_get(:PARSER)
+      node = parser.parse(str)
+      raise ParseError, "Failed to parse #{str}" if node.nil?
+
+      node.send(self.const_get(:CONVERSION_METHOD))
     end
-    
+
     def split_parse str, pattern=" "
-      str.split(pattern).map {|x| convert(parser.parse(x)) }
-    end  
-  end  
-end  
+      str.split(pattern).map {|x| parse(x) }
+    end
+  end
+end
 
-end
+end

data/lib/musicality/notation/parsing/pitch_parsing.rb

@@ -252,6 +252,7 @@ module Pitch
     if has_terminal?(@regexps[gr = '\A[Aa]'] ||= Regexp.new(gr), :regexp, index)
       r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
       r0.extend(LetterA0)
+      r0.extend(LetterA0)
       @index += 1
     else
       terminal_parse_failure('[Aa]')
@@ -281,6 +282,7 @@ module Pitch
     if has_terminal?(@regexps[gr = '\A[Bb]'] ||= Regexp.new(gr), :regexp, index)
       r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
       r0.extend(LetterB0)
+      r0.extend(LetterB0)
       @index += 1
     else
       terminal_parse_failure('[Bb]')
@@ -310,6 +312,7 @@ module Pitch
     if has_terminal?(@regexps[gr = '\A[Cc]'] ||= Regexp.new(gr), :regexp, index)
       r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
       r0.extend(LetterC0)
+      r0.extend(LetterC0)
       @index += 1
     else
       terminal_parse_failure('[Cc]')
@@ -339,6 +342,7 @@ module Pitch
     if has_terminal?(@regexps[gr = '\A[Dd]'] ||= Regexp.new(gr), :regexp, index)
       r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
       r0.extend(LetterD0)
+      r0.extend(LetterD0)
       @index += 1
     else
       terminal_parse_failure('[Dd]')
@@ -368,6 +372,7 @@ module Pitch
     if has_terminal?(@regexps[gr = '\A[Ee]'] ||= Regexp.new(gr), :regexp, index)
       r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
       r0.extend(LetterE0)
+      r0.extend(LetterE0)
       @index += 1
     else
       terminal_parse_failure('[Ee]')
@@ -397,6 +402,7 @@ module Pitch
     if has_terminal?(@regexps[gr = '\A[Ff]'] ||= Regexp.new(gr), :regexp, index)
       r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
       r0.extend(LetterF0)
+      r0.extend(LetterF0)
       @index += 1
     else
       terminal_parse_failure('[Ff]')
@@ -426,6 +432,7 @@ module Pitch
     if has_terminal?(@regexps[gr = '\A[Gg]'] ||= Regexp.new(gr), :regexp, index)
       r0 = instantiate_node(SyntaxNode,input, index...(index + 1))
       r0.extend(LetterG0)
+      r0.extend(LetterG0)
       @index += 1
     else
       terminal_parse_failure('[Gg]')

data/lib/musicality/notation/parsing/segment_parsing.rb

@@ -70,6 +70,9 @@ module Segment
         @index = i2
         r2 = nil
       else
+        if s2.size < 3
+          @terminal_failures.pop
+        end
         r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
       end
       s0 << r2

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

@@ -7,97 +7,56 @@ class NoteSequenceExtractor
     mark_slurring
     remove_bad_links
     calculate_offsets
-    establish_maps
+
     # now, ready to extract sequences!
   end
-  
+
   def extract_sequences cents_per_step = 10
-    return [] if @notes.empty?
-    
-    next_seqs = seqs_from_note(@notes.size-1, cents_per_step)
-    return next_seqs if @notes.one?
-    
-    complete_seqs = []
-    (@notes.size-2).downto(0) do |i|
-      cur_seqs = seqs_from_note(i, cents_per_step)
-      map = @maps[i]
-      
-      next_seqs.each do |next_seq|
-        p1 = nil
-        p2 = next_seq.elements.first.pitch
-        if p1 = map[:ties].key(p2)
-          cur_seq = cur_seqs.find {|x| x.elements.first.pitch == p1 }
-          NoteSequenceExtractor.tie_seqs(cur_seq, next_seq)
-        elsif p1 = map[:slurs].key(p2)
-          cur_seq = cur_seqs.find {|x| x.elements.first.pitch == p1 }
-          NoteSequenceExtractor.slur_seqs(cur_seq, next_seq)
-        elsif p1 = map[:full_glissandos].key(p2)
-          cur_seq = cur_seqs.find {|x| x.elements.first.pitch == p1 }
-          NoteSequenceExtractor.glissando_seqs(cur_seq, next_seq)
-        elsif p1 = map[:full_portamentos].key(p2)
-          cur_seq = cur_seqs.find {|x| x.elements.first.pitch == p1 }
-          NoteSequenceExtractor.portamento_seqs(cur_seq, next_seq, cents_per_step)
+    completed_seqs = []
+    continuing_sequences = {}
+
+    @notes.each_with_index do |note, idx|
+      offset = @offsets[idx]
+      duration = note.duration
+      attack = NoteSequenceExtractor.note_attack(note.articulation)
+      separation = NoteSequenceExtractor.note_separation(note.articulation, @slurring_flags[idx])
+
+      next_note = (idx == (@notes.size-1)) ? Note.quarter : @notes[idx+1]
+      continuation_map = NoteSequenceExtractor.continuation_map(note, next_note, separation)
+
+      new_continuing_sequences = {}
+
+      note.pitches.each do |p|
+        seq = if continuing_sequences.has_key?(p)
+          continuing_sequences[p].elements += note_pitch_elements(note, p, Attack::NONE, cents_per_step)
+          continuing_sequences.delete(p)
         else
-          complete_seqs.push next_seq
+          NoteSequence.new(offset, separation, note_pitch_elements(note, p, attack, cents_per_step))
         end
-      end      
-      next_seqs = cur_seqs
-    end
-    complete_seqs += next_seqs
-    return complete_seqs
-  end
-  
-  private
-  
-  def self.tie_seqs(cur_seq, next_seq)
-    cur_seq.elements.last.duration += next_seq.elements.first.duration
-    cur_seq.elements += next_seq.elements[1..-1]
-  end
-  
-  def self.slur_seqs(cur_seq, next_seq)
-    if next_seq.elements.first.attack == Attack::NORMAL
-      next_seq.elements.first.attack = Attack::NONE
-    end
-    cur_seq.separation = next_seq.separation
-    cur_seq.elements += next_seq.elements
-  end
 
-  def self.glissando_seqs(cur_seq, next_seq)
-    cur_seq.elements = GlissandoConverter.glissando_elements(cur_seq.last_pitch,
-      next_seq.first_pitch, cur_seq.full_duration, cur_seq.last_attack)
-    cur_seq.separation = next_seq.separation
-    cur_seq.elements += next_seq.elements
-  end
+        if continuation_map.include?(p)
+          new_continuing_sequences[continuation_map[p]] = seq
+        else
+          completed_seqs.push seq
+        end
+      end
 
-  def self.portamento_seqs(cur_seq, next_seq, cents_per_step)
-    cur_seq.elements = PortamentoConverter.portamento_elements(cur_seq.last_pitch,
-      next_seq.first_pitch, cents_per_step, cur_seq.full_duration, cur_seq.last_attack)
-    cur_seq.separation = Separation::NONE
-    cur_seq.elements += next_seq.elements    
-  end
-  
-  def seqs_from_note(idx, cents_per_step)
-    map = @maps[idx]
-    note = @notes[idx]
-    attack = NoteSequenceExtractor.note_attack(note.articulation)
-    separation = NoteSequenceExtractor.note_separation(note.articulation, @slurring_flags[idx])
-    offset = @offsets[idx]
-    note.pitches.map do |p|
-      if map[:half_glissandos].has_key?(p)
-        NoteSequence.new(offset, separation, 
-          GlissandoConverter.glissando_elements(
-            p, map[:half_glissandos][p], note.duration, attack))
-      elsif map[:half_portamentos].has_key?(p)
-        NoteSequence.new(offset, Separation::NONE, 
-          PortamentoConverter.portamento_elements(
-            p, map[:half_portamentos][p], cents_per_step, note.duration, attack))
-      else
-        NoteSequence.new(offset, separation,
-          [NoteSequence::Element.new(note.duration, p, attack)])
+      if continuing_sequences.any?
+        require 'pry'
+        binding.pry
+        # raise "Should be no previous continuing sequences remaining"
       end
+      continuing_sequences = new_continuing_sequences
     end
+
+    raise "Should be no previous continuing sequences remaining" if continuing_sequences.any?
+
+    completed_seqs.each {|seq| seq.simplify! }
+    return completed_seqs
   end
 
+  private
+
   def self.note_attack articulation
     case articulation
     when Articulations::NORMAL then Attack::NORMAL
@@ -137,7 +96,7 @@ class NoteSequenceExtractor
   def mark_slurring
     @slurring_flags = []
     under_slur = false
-    
+
     @slurring_flags = Array.new(@notes.size) do |i|
       note = @notes[i]
 
@@ -162,7 +121,7 @@ class NoteSequenceExtractor
       end
     end
   end
-    
+
   def calculate_offsets
     offset = 0.to_r
     @offsets = Array.new(@notes.size) do |i|
@@ -171,61 +130,50 @@ class NoteSequenceExtractor
       cur_offset
     end
   end
-  
-  def self.no_separation?(articulation, under_slur)
-    under_slur && (
-      articulation == Articulations::NORMAL ||
-      articulation == Articulations::TENUTO ||
-      articulation == Articulations::ACCENT
-    )
-  end
-  
-  def establish_maps
-    @maps = []
-    
-    @notes.each_index do |i|
-      map = { :ties => {}, :slurs => {}, :full_glissandos => {}, 
-        :full_portamentos => {}, :half_glissandos => {}, 
-        :half_portamentos => {}}
-      note = @notes[i]
-      
-      # Create a dummy note (with no pitches) for the last note to "link" to.
-      # This will allow half glissandos and half portamentos from the last note
-      next_note = (i == (@notes.size-1)) ? Note.quarter : @notes[i+1]
-      
-      no_separation = NoteSequenceExtractor.no_separation?(note.articulation, @slurring_flags[i])
-      
-      linked = note.pitches & note.links.keys
-      linked.each do |p|
-        l = note.links[p]
-        if l.is_a?(Link::Tie)
-          map[:ties][p] = p
-        elsif l.is_a?(Link::Glissando)
-          if next_note.pitches.include?(l.target_pitch)
-            map[:full_glissandos][p] = l.target_pitch
-          else
-            map[:half_glissandos][p] = l.target_pitch
-          end
-        elsif l.is_a?(Link::Portamento)
-          if next_note.pitches.include?(l.target_pitch)
-            map[:full_portamentos][p] = l.target_pitch
-          else
-            map[:half_portamentos][p] = l.target_pitch
-          end
-        end
+
+  def self.continuation_map note, next_note, separation
+    map = {}
+
+    linked = note.pitches & note.links.keys
+    targeted = []
+    linked.each do |p|
+      l = note.links[p]
+      if l.is_a?(Link::Tie)
+        map[p] = p
+      elsif l.is_a?(Link::TargetedLink) && next_note.pitches.include?(l.target_pitch)
+        map[p] = l.target_pitch
       end
-      
-      if(no_separation)
-        unlinked = note.pitches - linked
-        target_pitches = note.links.map {|p,l| l.is_a?(Link::Tie) ? p : l.target_pitch }
-        untargeted = next_note.pitches - target_pitches
-        Optimization.linking(unlinked, untargeted).each do |pitch,tgt_pitch|
-          map[:slurs][pitch] = tgt_pitch
-        end
+    end
+
+    if(separation == Separation::NONE)
+      unlinked = note.pitches - linked
+      untargeted = next_note.pitches - map.values
+      Optimization.linking(unlinked, untargeted).each do |pitch,tgt_pitch|
+        map[pitch] = tgt_pitch
+      end
+    end
+
+    return map
+  end
+
+  def note_pitch_elements note, pitch, attack, cents_per_step
+    duration = note.duration
+    link = note.links[pitch]
+    elements = if link && link.is_a?(Link::TargetedLink)
+      tgt_pitch = link.target_pitch
+      case link
+      when Link::Glissando
+        GlissandoConverter.glissando_elements(pitch, tgt_pitch, duration, attack)
+      when Link::Portamento
+        PortamentoConverter.portamento_elements(pitch, tgt_pitch, cents_per_step, duration, attack)
+      else
+        raise "Unexpected targeted link type"
       end
-      
-      @maps.push map
+    else
+      [ NoteSequence::Element.new(note.duration, pitch, attack) ]
     end
+
+    return elements
   end
 end
 

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

@@ -27,11 +27,30 @@ class NoteSequence
     @elements = elements
   end
 
+  # any consecutive elements with the same pitch and no attack will be combined
+  def simplify!
+    return if @elements.none?
+
+    prev_element = @elements[0]
+    idx = 1
+
+    while idx < @elements.size
+      element = @elements[idx]
+      if (element.pitch == prev_element.pitch) && (element.attack == Attack::NONE)
+        prev_element.duration += element.duration
+        @elements.delete_at(idx)
+      else
+        prev_element = element
+        idx += 1
+      end
+    end
+  end
+
   alias start offset
-  
+
   def offsets
     raise "contains no elements" if elements.empty?
-    
+
     off = @offset
     elements.map do |e|
       x = off
@@ -39,7 +58,7 @@ class NoteSequence
       x
     end
   end
-  
+
   def stop
     offsets.last + NoteSequence.adjust_duration(elements.last.duration, separation)
   end

data/lib/musicality/performance/supercollider/performer.rb

@@ -22,7 +22,7 @@ class Performer
     group = create_part_group parent_group, bundles
     set_start_volume volume_control_bus, bundles
     add_volume_control group, aux_audio_bus, volume_control_bus, lead_time, bundles
-    add_volume_changes volume_control_bus, lead_time, bundles
+    add_volume_changes group, volume_control_bus, lead_time, bundles
     add_part_notes group, aux_audio_bus, lead_time, bundles
 
     bundles
@@ -51,7 +51,7 @@ class Performer
     bundles.push vol_control.bundle_queue(lead_time / 2.0)
   end
 
-  def add_volume_changes volume_control_bus, lead_time, bundles
+  def add_volume_changes group, volume_control_bus, lead_time, bundles
     # change part volume
     part.dynamic_changes.each do |offset,change|
       case change

data/lib/musicality/performance/supercollider/sc_drum_kits.rb

@@ -0,0 +1,29 @@
+module Musicality
+
+module DrumKits
+
+SC_DRUM_KIT_01 = DrumKit.new(
+  DrumParts::BASS_DRUM => SuperCollider::SynthDefs::KICK2.settings,
+  DrumParts::SNARE_DRUM => SuperCollider::SynthDefs::SNARE_STEIN.settings,
+  DrumParts::CRASH_CYMBAL => SuperCollider::SynthDefs::CYMBALIC_MCLD.settings,
+  DrumParts::CLOSED_HI_HAT => SuperCollider::SynthDefs::CLOSED_HAT.settings,
+  DrumParts::OPEN_HI_HAT => SuperCollider::SynthDefs::OPEN_HAT.settings,
+  DrumParts::HI_TOM => SuperCollider::SynthDefs::TOM1.settings,
+  DrumParts::MED_TOM => SuperCollider::SynthDefs::TOM1.settings,
+  DrumParts::LOW_TOM => SuperCollider::SynthDefs::TOM1.settings,
+)
+
+SC_DRUM_KIT_02 = DrumKit.new(
+  DrumParts::BASS_DRUM => SuperCollider::SynthDefs::KICK_CHIRP.settings,
+  DrumParts::SNARE_DRUM => SuperCollider::SynthDefs::SNARE1.settings,
+  DrumParts::CRASH_CYMBAL => SuperCollider::SynthDefs::CYMBALIC_MCLD.settings,
+  DrumParts::CLOSED_HI_HAT => SuperCollider::SynthDefs::HIHAT1.settings,
+  DrumParts::OPEN_HI_HAT => SuperCollider::SynthDefs::HIHAT1.settings(:release => 0.6),
+  DrumParts::HI_TOM => SuperCollider::SynthDefs::FM_TOM.settings,
+  DrumParts::MED_TOM => SuperCollider::SynthDefs::FM_TOM.settings,
+  DrumParts::LOW_TOM => SuperCollider::SynthDefs::FM_TOM.settings,
+)
+
+end
+
+end