music-performance 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d523ae35fe6714368362b37241e3ffd10c0e2982
+  data.tar.gz: 3604e251beb16c2095e9c9d8e90b889b0bb385a7
+SHA512:
+  metadata.gz: bc6d3bf49947281586e433f301048c6a64eff08611aa8a8565c40a4a60f52f1357b8436feb56d5d92cc1a400bdf63e3d99c161ccf24960e81c75ffc9cc18cc33
+  data.tar.gz: f4104ce48fbc02e4790df8511d6afadf668466578ffa5ee0e2ee43b0014c840ae988f3eb1bbb36a1d9cae169ce43289cd62c5caa5eaaf055659a2c02a05ab674

data/.document

@@ -0,0 +1,3 @@
+- 
+ChangeLog.rdoc
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,7 @@
+Gemfile.lock
+doc/
+pkg/
+vendor/cache/*.gem
+.yardoc
+*~
+.project

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.ruby-version

@@ -0,0 +1 @@
+2.0.0

data/.yardopts

@@ -0,0 +1 @@
+--markup rdoc --title "music-performance Documentation" --protected

data/ChangeLog.rdoc

@@ -0,0 +1,5 @@
+=== 0.1.0 / 2014-09-16
+
+* Tear off music performance-related code from musicality gem, into a separate gem called music-performance.
+
+

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 James Tunnell
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,28 @@
+= music-performance
+
+* {Homepage}[https://github.com/jamestunnell/music-performance]
+* {Issues}[https://github.com/jamestunnell/music-performance/issues]
+* {Documentation}[http://rubydoc.info/gems/music-performance/frames]
+* {Email}[mailto:jamestunnell@gmail.com]
+
+== Description
+
+Classes for preparing a music score for computer performance (e.g. via MIDI).
+
+== Features
+
+== Examples
+
+  require 'music-performance'
+
+== Requirements
+
+== Install
+
+  $ gem install music-performance
+
+== Copyright
+
+Copyright (c) 2012 James Tunnell
+
+See LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'rubygems'
+
+begin
+  require 'bundler'
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install bundler` to install Bundler."
+  exit -1
+end
+
+begin
+  Bundler.setup(:development)
+rescue Bundler::BundlerError => e
+  warn e.message
+  warn "Run `bundle install` to install missing gems."
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :test    => :spec
+task :default => :spec
+
+require "bundler/gem_tasks"
+
+require 'yard'
+YARD::Rake::YardocTask.new  
+task :doc => :yard
+
+task :make_samples do
+  current_dir = Dir.getwd
+  samples_dir = File.join(File.dirname(__FILE__), 'samples')
+  Dir.chdir samples_dir
+  
+  samples = []
+  Dir.glob('**/make*.rb') do |file|
+    samples.push File.expand_path(file)
+  end
+  
+  samples.each do |sample|
+    dirname = File.dirname(sample)
+    filename = File.basename(sample)
+    
+    Dir.chdir dirname
+    ruby filename
+  end
+
+  Dir.chdir current_dir
+end

data/bin/midify

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+
+exe_name = File.basename(__FILE__)
+
+doc = <<DOCOPT
+Loads a music-transcription score from YAML file, and converts to MIDI file.
+
+Usage:
+  #{exe_name} <input>
+  #{exe_name} <input> <output>
+  #{exe_name} -h | --help
+  #{exe_name} --version
+
+Options:
+  -h --help     Show this screen.
+  --version     Show version.
+
+DOCOPT
+
+require 'docopt'
+begin
+  require "pp"
+  args = Docopt::docopt(doc)
+  pp args
+rescue Docopt::Exit => e
+  puts e.message
+  exit
+end
+
+require 'yaml'
+require 'music-transcription'
+require 'music-performance'
+include Music
+
+fin_name = args["<input>"]
+File.open(fin_name) do |fin|
+  print "Reading file '#{fin_name}'..."
+  score = YAML.load(fin.read)
+  if score.is_a? Hash
+    score = Transcription::Score.unpack(score)
+  end
+  puts "complete"
+  
+  if score.valid?
+    print "Making MIDI sequence..."
+    seq = Performance::ScoreSequencer.new(score).make_midi_seq
+    puts "complete"  
+  
+    fout_name = args["<output>"]
+    if fout_name.nil?
+      fout_name = "#{File.dirname(fin_name)}/#{File.basename(fin_name,File.extname(fin_name))}.mid"
+    end
+    print "Writing file '#{fout_name}'..."
+    File.open(fout_name, 'wb'){ |fout| seq.write(fout) }
+    puts "complete"    
+  else
+    puts "Failed to load a valid score."
+    puts "Errors:"
+    puts score.errors.join("\n")
+  end
+end

data/lib/music-performance.rb

@@ -0,0 +1,25 @@
+require 'music-transcription'
+
+require 'music-performance/version'
+
+require 'music-performance/model/note_attacks'
+require 'music-performance/model/note_sequence'
+
+require 'music-performance/util/interpolation'
+require 'music-performance/util/piecewise_function'
+require 'music-performance/util/value_computer'
+require 'music-performance/util/optimization'
+require 'music-performance/util/note_linker'
+
+require 'music-performance/conversion/note_time_converter'
+require 'music-performance/conversion/score_time_converter'
+require 'music-performance/conversion/score_collator'
+require 'music-performance/conversion/glissando_converter'
+require 'music-performance/conversion/portamento_converter'
+require 'music-performance/conversion/note_sequence_extractor'
+
+require 'midilib'
+require 'music-performance/arrangement/midi/midi_util'
+require 'music-performance/arrangement/midi/midi_events'
+require 'music-performance/arrangement/midi/part_sequencer'
+require 'music-performance/arrangement/midi/score_sequencer'

data/lib/music-performance/arrangement/midi/midi_events.rb

@@ -0,0 +1,9 @@
+module Music
+module Performance
+
+NoteOnEvent = Struct.new(:notenum, :accented)
+NoteOffEvent = Struct.new(:notenum)
+VolumeExpressionEvent = Struct.new(:volume)
+
+end
+end

data/lib/music-performance/arrangement/midi/midi_util.rb

@@ -0,0 +1,38 @@
+module Music
+module Performance
+
+class MidiUtil
+  QUARTER = Rational(1,4)    
+  def self.delta duration, ppqn
+    pulses = (duration / QUARTER) * ppqn
+    return pulses.round
+  end
+  
+  def self.usec_per_qnote notes_per_sec
+    spn = 1.0 / notes_per_sec
+    spqn = spn / 4.0
+    return (spqn * 1_000_000).to_i
+  end
+  
+  p0 = Music::Transcription::Pitch.new(octave:-1,semitone:0)
+  MIDI_NOTENUMS = Hash[
+    (0..127).map do |note_num|
+      [ p0.transpose(note_num), note_num ]
+    end
+  ]
+  
+  def self.pitch_to_notenum pitch
+    MIDI_NOTENUMS[pitch.round]
+  end
+  
+  def self.dynamic_to_volume dynamic
+    (dynamic * 127).round
+  end
+  
+  def self.note_velocity(accented)
+    accented ? 112 : 70
+  end
+end
+
+end
+end

data/lib/music-performance/arrangement/midi/part_sequencer.rb

@@ -0,0 +1,121 @@
+module Music
+module Performance
+
+class PartSequencer
+  def initialize part, dynamics_sample_rate: 50, cents_per_step: 10
+    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_by {|x| x[0] }
+  end
+  
+  def make_midi_track midi_sequence, part_name, channel, ppqn
+    track = begin_track(midi_sequence, part_name, channel)
+    
+    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 NoteOnEvent
+        vel = MidiUtil.note_velocity(event.accented)
+        MIDI::NoteOn.new(channel, event.notenum, vel, delta)
+      when NoteOffEvent
+        MIDI::NoteOff.new(channel, event.notenum, 127, delta)
+      when VolumeExpressionEvent
+        MIDI::Controller.new(channel, MIDI::CC_EXPRESSION_CONTROLLER, event.volume, delta)
+      end
+      
+      prev_offset = offset
+    end
+   return track
+  end
+  
+  private
+  
+  #def add_event events_hash, offset, event
+  #  if events_hash.has_key? offset
+  #    events_hash[offset].push event
+  #  else
+  #    events_hash[offset] = [ event ]
+  #  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, NoteOnEvent.new(note_num, accented)]
+        note_events.push [off_at, NoteOffEvent.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? Music::Transcription::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, VolumeExpressionEvent.new(volume)]
+      end
+      prev = sample
+    end
+    
+    return dynamic_events
+  end
+
+  def begin_track midi_sequence, part_name, channel
+    # Track to hold part notes
+    track = MIDI::Track.new(midi_sequence)
+    
+    # Name the track and instrument
+    track.name = part_name.to_s
+    track.instrument = MIDI::GM_PATCH_NAMES[0]
+    
+    # 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, 1, 0)
+    
+    return track
+  end
+end
+
+end
+end

data/lib/music-performance/arrangement/midi/score_sequencer.rb

@@ -0,0 +1,33 @@
+module Music
+module Performance
+
+class ScoreSequencer
+  def initialize score
+    start_nps = NoteTimeConverter.notes_per_second(score.start_tempo,
+      score.start_meter.beat_duration)
+    @start_usec_per_qnote = MidiUtil.usec_per_qnote(start_nps)
+    @parts = ScoreCollator.new(score).collate_parts
+  end
+
+  def make_midi_seq
+    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(@start_usec_per_qnote)
+    track0.events << MIDI::MetaEvent.new(MIDI::META_SEQ_NAME, 'Sequence Name')
+    
+    channel = 0
+    @parts.each do |part_name,part|
+      pseq = PartSequencer.new(part)
+      seq.tracks << pseq.make_midi_track(seq, part_name, channel, seq.ppqn)
+      channel += 1
+    end
+    
+    return seq
+  end
+end
+
+end
+end

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

@@ -0,0 +1,36 @@
+module Music
+module Performance
+
+class GlissandoConverter
+  def self.glissando_pitches(start_pitch, target_pitch)
+    start, finish = start_pitch.total_semitones, target_pitch.total_semitones
+    if finish >= start
+      semitones = start.ceil.upto(finish.floor).to_a
+    else
+      semitones = start.floor.downto(finish.ceil).to_a
+    end
+    
+    if semitones.empty? || semitones[0] != start
+      semitones.unshift(start)
+    end
+    
+    if semitones.size > 1 && semitones[-1] == finish
+      semitones.pop
+    end
+    
+    semitones.map do |semitone|
+      Music::Transcription::Pitch.from_semitones(semitone)
+    end
+  end
+
+  def self.glissando_elements(start_pitch, target_pitch, duration, accented)
+    pitches = glissando_pitches(start_pitch, target_pitch)
+    subdur = Rational(duration, pitches.size)
+    pitches.map do |pitch|
+      LegatoElement.new(subdur, pitch, accented)
+    end
+  end
+end
+
+end
+end