musicality 0.8.0 → 0.9.0

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

@@ -2,14 +2,14 @@ module Musicality
 
 class Score
   class Timed < Score
-    def to_midi_seq instr_map = {}
-      ScoreSequencer.new(self).make_midi_seq(instr_map)
+    def to_midi_seq **kwargs
+      ScoreSequencer.new(self).make_midi_seq(**kwargs)
     end
   end
 
-  class TempoBased < Score
-    def to_midi_seq tempo_sample_rate, instr_map = {}
-      to_timed(tempo_sample_rate).to_midi_seq(instr_map)
+  class Tempo < Score
+    def to_midi_seq tempo_sample_rate, **kwargs
+      to_timed(tempo_sample_rate).to_midi_seq(**kwargs)
     end
   end
 end

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

@@ -0,0 +1,8 @@
+module Musicality
+  module Attack
+    NONE = :none
+    NORMAL = :normal
+    TENUTO = :tenuto
+    ACCENT = :accent
+  end
+end

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

@@ -0,0 +1,23 @@
+module Musicality
+
+module DurationFunctions
+  TENUTO_DURATION = Function::Linear.new([0,0],[1,1])
+
+  NORMAL_DURATION = Function.new(0...Float::INFINITY) do |x|
+    x - Rational(1,8) * (1 - Math.exp(-1.75*x))
+  end
+
+  PORTATO_DURATION = Function.new(0...Float::INFINITY) do |x|
+    x - Rational(2,8) * (1 - Math.exp(-1.75*x))
+  end
+
+  STACCATO_DURATION = Function.new(0...Float::INFINITY) do |x|
+    x - Rational(3,8) * (1 - Math.exp(-1.75*x))
+  end
+
+  STACCATISSIMO_DURATION = Function.new(0...Float::INFINITY) do |x|
+    x - Rational(4,8) * (1 - Math.exp(-1.75*x))
+  end
+end
+
+end

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

@@ -1,111 +1,68 @@
 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)
+  Element = Struct.new(:duration, :pitch, :attack)
 
-    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))
+  def self.adjust_duration duration, separation
+    function = case separation
+    when Separation::TENUTO
+      DurationFunctions::TENUTO_DURATION
+    when Separation::PORTATO
+      DurationFunctions::PORTATO_DURATION
+    when Separation::STACCATO
+      DurationFunctions::STACCATO_DURATION
+    when Separation::STACCATISSIMO
+      DurationFunctions::STACCATISSIMO_DURATION
     else
-      x - (1/16.0)*(1/(1+2**(-y)))
+      DurationFunctions::NORMAL_DURATION
     end
+
+    function.at(duration)
   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
+  attr_accessor :offset, :separation, :elements
+  def initialize offset, separation, elements = []
+    @offset = offset
+    @separation = separation
+    @elements = elements
   end
+
+  alias start offset
+  
+  def offsets
+    raise "contains no elements" if elements.empty?
     
-  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
+    off = @offset
+    elements.map do |e|
+      x = off
+      off += e.duration
+      x
     end
-    stop = offset + NoteSequence.adjust_duration(last.duration, last.articulation)
-    
-    new(start, stop, pitches, attacks)
+  end
+  
+  def stop
+    offsets.last + NoteSequence.adjust_duration(elements.last.duration, separation)
   end
 
-  def duration; @stop - @start; end
+  def duration
+    stop - offset
+  end
+
+  def full_duration
+    offsets.last + elements.last.duration
+  end
+
+  def first_pitch
+    elements.first.pitch
+  end
+
+  def last_pitch
+    elements.last.pitch
+  end
+
+  def last_attack
+    elements.last.attack
+  end
 end
 
 end

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

@@ -0,0 +1,10 @@
+module Musicality
+  module Separation
+    NONE = :none
+    TENUTO = :tenuto
+    NORMAL = :normal
+    PORTATO = :portato
+    STACCATO = :staccato
+    STACCATISSIMO = :staccatissimo
+  end
+end

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

@@ -0,0 +1,13 @@
+module Musicality
+module SuperCollider
+
+ADD_HEAD = 0
+ADD_TAIL = 1
+ADD_BEFORE = 2
+ADD_AFTER = 3
+ADD_REPLACE = 4
+
+ADD_ACTIONS = [ ADD_BEFORE, ADD_AFTER, ADD_HEAD, ADD_TAIL, ADD_REPLACE ]
+
+end
+end

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

@@ -0,0 +1,18 @@
+module Musicality
+module SuperCollider
+
+class Bundle
+  attr_reader :time, :messages
+  def initialize time, *messages
+    @time = time
+    @messages = messages
+  end
+
+  def to_sclang
+    raise "Bundle contains no messages" if @messages.empty?
+    "[ #{@time.to_f}, #{@messages.map {|m| m.to_sclang }.join(", ")} ]"
+  end
+end
+
+end
+end

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

@@ -0,0 +1,125 @@
+module Musicality
+module SuperCollider
+
+class Conductor
+  def initialize score
+    unless score.is_a?(Score::Timed)
+      raise ArgumentError, "The given score is not a Score::Timed. \
+      Convert it first using ScoreConverter."
+    end
+
+    parts = score.collated? ? score.parts : ScoreCollator.new(score).collate_parts
+    @performers = Hash[ parts.map do |name, part|
+      [name, Performer.new(part)]
+    end]
+  end
+
+  def perform base_fpath, selected_parts: @performers.keys, verbose: false, lead_time: 0.1
+    bundles = bundles(selected_parts, lead_time)
+    fpath = write_sc_code bundles, base_fpath
+    exec_sc_code fpath, bundles.last.time, verbose
+  end
+
+  def bundles selected_parts = @performers.keys, lead_time
+    Node.reset_id_counter
+
+    default_group = Group.default(nil)
+    aux_audio_bus = 16
+    volume_control_bus = 0
+    bundle_kwargs = {
+      :parent_group => default_group,
+      :aux_audio_bus => aux_audio_bus,
+      :volume_control_bus => volume_control_bus,
+      :lead_time => lead_time
+    }
+
+    all_bundles = [ default_group.bundle_queue(0.0) ]
+    selected_parts.each do |name|
+      bundles = @performers[name].bundles(**bundle_kwargs)
+      bundle_kwargs[:aux_audio_bus] += 2
+      bundle_kwargs[:volume_control_bus] += 1
+      all_bundles.concat bundles
+    end
+    all_bundles = all_bundles.sort_by {|b| b.time }
+    default_group.free_all
+    all_bundles.push(default_group.bundle_queue(lead_time+all_bundles.last.time))
+
+    coalesced_bundles = []
+    all_bundles.each do |bundle|
+      if coalesced_bundles.any? && coalesced_bundles.last.time == bundle.time
+        coalesced_bundles.last.messages.concat bundle.messages
+      else
+        coalesced_bundles.push bundle
+      end
+    end
+
+    return coalesced_bundles
+  end
+
+  private
+
+  BASE_FPATH_PLACEHOLDER = "BASE_FPATH"
+  SYNTHDEFS_PLACEHOLDER = "SYNTHDEFS"
+  COMPLETION_MSG = "Work complete."
+  POST_PID_MSG = "sclang pid:"
+
+  SC_HEADER = <<SCLANG
+// auto-generated by Musicality
+
+(\"#{POST_PID_MSG}\" + thisProcess.pid).postln;
+
+#{SYNTHDEFS_PLACEHOLDER}
+
+(
+  x = [
+SCLANG
+
+  SC_FOOTER = <<SCLANG
+  ];
+
+  f = File(\"#{BASE_FPATH_PLACEHOLDER}.osc\","w");
+  x.do({ arg item, i;
+    var bytes = item.asRawOSC;
+    f.write(bytes.size);
+    f.write(bytes);
+  });
+  f.close;
+
+  \"#{COMPLETION_MSG}\".postln;
+);
+SCLANG
+
+  def write_sc_code bundles, base_fpath
+    fpath = "#{base_fpath}.scd"
+    File.open(fpath, "w") do |f|
+      synthdefs = [ SynthDefs::VOLUME_CONTROL, SynthDefs::VOLUME_CHANGE ] + @performers.values.map {|p| p.settings.synthdef }
+
+      f.write SC_HEADER.gsub(SYNTHDEFS_PLACEHOLDER, synthdefs.map {|s| s.to_sclang }.join("\n\n"))
+      f.write bundles.map {|b| "    " + b.to_sclang }.join(",\n") + "\n"
+      f.write SC_FOOTER.gsub(BASE_FPATH_PLACEHOLDER, base_fpath)
+    end
+    fpath
+  end
+
+  def exec_sc_code fpath, last_time, verbose
+    post_sclang_pid = Regexp.new(POST_PID_MSG + " ([0-9]+)")
+
+    sclang_pid = nil
+    IO.popen("sclang \"#{fpath}\"") do |io|
+      pid = io.pid      
+      while response = io.gets
+        puts response if verbose
+
+        case response.chomp
+        when post_sclang_pid
+          sclang_pid = $1.to_i
+        when COMPLETION_MSG
+          Process.kill 'INT', sclang_pid
+        end
+      end
+    end
+  end
+end
+
+end
+end

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

@@ -0,0 +1,71 @@
+module Musicality
+module SuperCollider
+
+class Group < Node
+  def initialize server, group, add_action, target_id, parallel
+    raise ArgumentError unless ADD_ACTIONS.include?(add_action)
+    super server, group
+
+    send_msg(Message.new(parallel ? '/p_new' : '/g_new',
+      id, add_action, target_id))
+  end
+
+  def self.default server, parallel = false
+    new(server, nil, ADD_TAIL, 0, parallel)
+  end
+
+  def self.after target, parallel = false
+    raise ArgumentError unless target.is_a?(Node)
+    new target.server, target.group, ADD_AFTER, target.id, parallel
+  end
+  
+  def self.before target, parallel = false
+    raise ArgumentError unless target.is_a?(Node)
+    new target.server, target.group, ADD_BEFORE, target.id, parallel
+  end
+  
+  def self.head target, parallel = false
+    raise ArgumentError unless target.is_a?(Group)
+    new target.server, target, ADD_HEAD, target.id, parallel
+  end
+  
+  def self.tail target, parallel = false
+    raise ArgumentError unless target.is_a?(Group)
+    new target.server, target, ADD_TAIL, target.id, parallel
+  end
+    
+  def self.replace target, parallel = false
+    raise ArgumentError unless target.is_a?(Node)
+    new target.server, target.group, ADD_REPLACE, target.id, parallel
+  end
+
+  def head node
+    raise ArgumentError unless node.is_a?(Node)
+    send_msg(Message.new('/g_head', id, node.id))
+  end
+
+  def tail node
+    raise ArgumentError unless node.is_a?(Node)
+    send_msg(Message.new('/g_tail', id, node.id))
+  end
+
+  def free_all
+    send_msg(Message.new('/g_freeAll', id))
+  end
+
+  def deep_free
+    send_msg(Message.new('/g_deepFree', id))
+  end
+
+  def dump_tree flag
+    send_msg(Message.new('/g_dumpTree', id, flag ? 1 : 0))
+  end
+
+  def query_tree
+    raise NotImplementedError
+    # TODO
+  end
+end
+
+end
+end