musicality 0.8.0 → 0.9.0

data/lib/musicality/printing/lilypond/pitch_class_engraving.rb

@@ -0,0 +1,22 @@
+module Musicality
+
+class PitchClass
+  def self.to_lilypond pc, sharpit = false
+    case pc
+    when 0 then "c"
+    when 1 then sharpit  ? "cis" : "des"
+    when 2 then "d"
+    when 3 then sharpit  ? "dis" : "ees"
+    when 4 then "e"
+    when 5 then "f"
+    when 6 then sharpit  ? "fis" : "ges"
+    when 7 then "g"
+    when 8 then sharpit  ? "gis" : "aes"
+    when 9 then "a"
+    when 10 then sharpit  ? "ais" : "bes"
+    when 11 then "b"
+    end
+  end
+end
+
+end

data/lib/musicality/printing/lilypond/pitch_engraving.rb

@@ -2,21 +2,8 @@ module Musicality
 
 class Pitch
   def to_lilypond sharpit = false
-    output = case semitone
-    when 0 then "c"
-    when 1 then sharpit  ? "cis" : "des"
-    when 2 then "d"
-    when 3 then sharpit  ? "dis" : "ees"
-    when 4 then "e"
-    when 5 then "f"
-    when 6 then sharpit  ? "fis" : "ges"
-    when 7 then "g"
-    when 8 then sharpit  ? "gis" : "aes"
-    when 9 then "a"
-    when 10 then sharpit  ? "ais" : "bes"
-    when 11 then "b"
-    end
-    
+    output = PitchClass.to_lilypond(semitone, sharpit)
+
     if octave > 3
       output += "'"*(octave - 3)
     elsif octave < 3

data/lib/musicality/printing/lilypond/score_engraver.rb

@@ -2,104 +2,75 @@ module Musicality
 
 class ScoreEngraver
   LILYPOND_VERSION = "2.18.2"
-  MAX_LINE_LEN = 76
 
   def initialize score
-    case score
-    when Score::Measured
-      @start_meter = score.start_meter
-    when Score::Unmeasured
-      @start_meter = Meters::FOUR_FOUR
-    else
-      raise TypeError, "Only tempo-based score support Lilypond conversion"
-    end
+    @start_meter = score.start_meter
+    @meter_changes = score.meter_changes
+    @start_key = score.start_key
+    @key_changes = score.key_changes
 
     @parts = score.collated? ? score.parts : ScoreCollator.new(score).collate_parts
-    @title = score.title
-    @composer = score.composer
+    @parts.each do |part_name, part|
+      unless part.lilypond_settings
+        part.settings.push LilypondSettings.new(part_name)
+      end
+    end
+
+    @header = ScoreEngraver.header score.title, score.composer
+    @part_titles = ScoreEngraver.figure_part_titles @parts
+  end
+
+  def self.figure_part_titles parts    
+    instr_name_totals = Hash.new(0)
+    instr_name_used = Hash.new(0)
+    part_titles = Hash[
+      parts.map do |part_name, part|
+        instr_name = part.lilypond_settings.instrument_name
+        instr_name_totals[instr_name] += 1
+        [part_name, instr_name]
+      end
+    ]
+
+    needs_number = parts.keys.select {|part_name| instr_name_totals[part_titles[part_name]] > 1 }
+    needs_number.each do |part_name|
+      title = part_titles[part_name]
+      part_titles[part_name] = "#{title} #{instr_name_used[title] += 1}"
+    end
+
+    return part_titles
   end
 
   # Generate a Lilypond header for the score
-  def header
+  def self.header title, composer
     output = "\\version \"#{LILYPOND_VERSION}\"\n"
     output += "\\header {\n"
-    if @title
-      output += "  title = \"#{@title}\"\n"
+    if title
+      output += "  title = \"#{title}\"\n"
     end
-    if @composer
-      output += "  composer = \"#{@composer}\"\n"
+    if composer
+      output += "  composer = \"#{composer}\"\n"
     end
     output += "}\n"
 
     return output
   end
 
-  # Generate a Lilypond staff for the given part
-  def staff part, part_title, master: false
-    clef = ScoreEngraver.best_clef(part.notes)
-    output = "  \\new Staff {\n"
-    output += "    \\set Staff.instrumentName = \\markup { \"#{part_title}\" }\n"
-    output += "    \\clef #{clef}\n"
-    if(master)
-      output += "    \\time #{@start_meter.to_lilypond}\n"
-    end
-
-    line = "    "
-    part.notes.each_index do |i|
-      note = part.notes[i]
-      begin
-        str = note.to_lilypond + " "
-      rescue UnsupportedDurationError => e
-        binding.pry
-      end
-
-      if (line.size + str.size) > MAX_LINE_LEN
-        output += line + "\n"
-        line = "    "
-      end
-      line += str
-    end
-    output += line + "\n"
-
-    output += "  }\n"
-  end
-
-  # @param [Hash] part_names A hash for titling parts differently than their names
-  # @param [Array] selected_parts The names of parts selected for engraving
-  def make_lilypond selected_parts: @parts.keys, part_titles: {}
-    (selected_parts - part_titles.keys).each do |part_name|
-      part_titles[part_name] = part_name
-    end
-    output = header
+  def make_lilypond selected_parts = @parts.keys
+    output = @header
     output += "{\n  <<\n"
     master = true
     selected_parts.each do |part_name|
       part = @parts[part_name]
-      part_title = part_titles[part_name]
-      output += staff part, part_title, master: master
+      part_title = @part_titles[part_name]
+      pe = PartEngraver.new(part, part_title)
+      output += pe.make_lilypond(@start_key, @start_meter, 
+        key_changes: @key_changes, meter_changes: @meter_changes,
+        master: master)
       master = false if master
     end
     output += "  >>\n}\n"
     return output
   end
-
-  def self.best_clef notes
-    ranges = { "treble" => Pitches::C4..Pitches::A5, 
-                "bass" => Pitches::E2..Pitches::C4,
-                "tenor" => Pitches::B2..Pitches::G4 }
-    range_scores = { "treble" => 0, "bass" => 0, "tenor" => 0 }
-    notes.each do |n|
-      n.pitches.each do |p|
-        ranges.each do |name,range|
-          if p >= range.min && p <= range.max
-            range_scores[name] += n.duration
-          end
-        end
-      end
-    end
-    range_score = range_scores.max_by {|range,score| score}
-    return range_score[0]
-  end
 end
 
 end

data/lib/musicality/printing/lilypond/score_engraving.rb

@@ -1,10 +1,10 @@
 module Musicality
 
 class Score
-  class TempoBased < Score
+  class Tempo < Score
     # See ScoreEngraver#make_lilypond for details on supported keyword args
-    def to_lilypond **kwargs
-      ScoreEngraver.new(self).make_lilypond(**kwargs)
+    def to_lilypond selected_parts = @parts.keys
+      ScoreEngraver.new(self).make_lilypond(selected_parts)
     end
   end
 end

data/lib/musicality/project/create_tasks.rb

@@ -0,0 +1,31 @@
+module Musicality
+
+class Project
+  def self.create_tasks config
+    score_files = Rake::FileList[File.join(config[:scores_dir],"**/*.score")]
+    
+    yaml_task = Tasks::FileRaker::YAML.new(score_files)
+    
+    tempo_sample_rate = config[:tempo_sample_rate]
+    lilypond_task = Tasks::FileRaker::LilyPond.new(yaml_task.files)
+    midi_task = Tasks::FileRaker::MIDI.new(yaml_task.files, tempo_sample_rate)
+    supercollider_task = Tasks::FileRaker::SuperCollider.new(yaml_task.files, tempo_sample_rate)
+    
+    sample_rate, sample_format = config[:audio_sample_rate], config[:audio_sample_format]
+    wav_task = Tasks::FileRaker::Audio.new(supercollider_task.files, :wav, sample_rate, sample_format)
+    aiff_task = Tasks::FileRaker::Audio.new(supercollider_task.files, :aiff, sample_rate, sample_format)
+    flac_task = Tasks::FileRaker::Audio.new(supercollider_task.files, :flac, sample_rate, sample_format)
+    
+    pdf_task = Tasks::FileRaker::Visual.new(lilypond_task.files, :pdf)
+    png_task = Tasks::FileRaker::Visual.new(lilypond_task.files, :png)
+    ps_task = Tasks::FileRaker::Visual.new(lilypond_task.files, :ps)
+
+    outfiles = (
+        yaml_task.files + midi_task.files + supercollider_task.files + wav_task.files + 
+        aiff_task.files + flac_task.files + pdf_task.files + png_task.files + ps_task.files
+    ).select {|fname| File.exists? fname }
+    clean_task = Tasks::FileCleaner.new(outfiles)  
+  end
+end
+
+end

data/lib/musicality/project/file_cleaner.rb

@@ -0,0 +1,19 @@
+module Musicality
+module Tasks
+
+class FileCleaner < Rake::TaskLib
+  def initialize outfiles
+    task :clean do
+      if outfiles.any?
+        puts "Deleting output files:"
+        outfiles.each do |fname|
+          puts " " + fname
+          File.delete fname
+        end
+      end
+    end
+  end
+end
+
+end
+end

data/lib/musicality/project/file_raker.rb

@@ -0,0 +1,107 @@
+module Musicality
+module Tasks
+
+class FileRaker < Rake::TaskLib
+  attr_reader :files, :task_name, :file_ext
+  
+  def initialize parent_filelist, task_name, file_ext, &rule_block
+    raise ArgumentError, "parent filelist is empty" if parent_filelist.empty?
+    raise ArgumentError, "no rule block given" unless block_given?
+    
+    @task_name, @file_ext = task_name, file_ext
+    @files = parent_filelist.ext(file_ext)
+    
+    task task_name => @files
+    
+    parent_exts = parent_filelist.map {|str| File.extname(str) }.uniq
+    raise ArgumentError, "multiple file extensions in parent filelist: #{parent_filelist}" unless parent_exts.one?
+    parent_ext = parent_exts.first
+    
+    rule file_ext => parent_ext do |t|
+      rule_block.call(t)
+    end
+  end
+  
+  class YAML < FileRaker
+    def initialize score_files
+      super(score_files, :yaml, ".yml") do |t|
+        puts "#{t.source} -> #{t.name}"
+        yml = ScoreDSL.load(t.source).score.pack.to_yaml
+        File.write(t.name, yml)
+      end
+    end
+  end
+  
+  class LilyPond < FileRaker
+    def initialize yaml_files
+      super(yaml_files, :lilypond, ".ly") do |t|
+        sh "lilify \"#{t.sources[0]}\""
+      end
+    end
+  end
+  
+  class MIDI < FileRaker
+    def initialize yaml_files, tempo_sample_rate
+      super(yaml_files, :midi, ".mid") do |t|
+        sh "midify \"#{t.sources[0]}\" --srate=#{tempo_sample_rate}"
+      end
+    end
+  end
+  
+  class SuperCollider < FileRaker
+    def initialize yaml_files, tempo_sample_rate
+      super(yaml_files, :supercollider, ".osc") do |t|
+        sh "collidify \"#{t.sources[0]}\" --srate=#{tempo_sample_rate}"
+      end
+    end
+  end
+  
+  class Audio < FileRaker
+    def check_sample_format audio_file_type, sample_format
+      combination_okay = case audio_file_type
+      when :wav
+        sample_format != "int8"
+      when :flac
+        !["int32","float","mulaw","alaw"].include?(sample_format)
+      else
+        true  
+      end
+
+      unless combination_okay
+        raise ConfigError, "#{audio_file_type} file format can not be used with #{sample_format} sample format"
+      end
+    end
+
+    def initialize osc_files, audio_file_type, sample_rate, sample_format
+      super(osc_files, audio_file_type, ".#{audio_file_type}") do |t|
+        check_sample_format audio_file_type, sample_format
+
+        osc_fpath = t.sources[0]
+        out_fpath = File.join(File.dirname(osc_fpath), File.basename(osc_fpath, File.extname(osc_fpath)) + ".#{audio_file_type}")
+        
+        cmd_line = "scsynth -N \"#{osc_fpath}\" _ \"#{out_fpath}\" #{sample_rate} #{audio_file_type} #{sample_format}"
+        IO.popen(cmd_line) do |pipe|
+          while response = pipe.gets
+            puts response
+            if /Couldn't open non real time command file/ =~ response
+              puts "The #{sample_format} sample format is not compatible with file format"
+              File.delete(out_fpath)
+              break
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  class Visual < FileRaker
+    def initialize lilypond_files, visual_file_type
+      super(lilypond_files, visual_file_type, ".#{visual_file_type}") do |t|
+        sh "lilypond #{t.sources[0]} --#{visual_file_type}"
+      end
+    end
+  end
+end
+
+end
+end

data/lib/musicality/project/load_config.rb

@@ -0,0 +1,43 @@
+module Musicality
+
+class Project
+  CONFIG_FILE_NAME = "config.yml"
+
+  DEFAULT_CONFIG = {
+    :scores_dir => "scores",
+    :tempo_sample_rate => 200,
+    :audio_sample_rate => 44100, 
+    :audio_sample_format => "int16"
+  }
+
+  SAMPLE_FORMATS = ["int8", "int16", "int24", "int32", "mulaw", "alaw", "float"]
+
+  class ConfigError < RuntimeError
+  end
+
+  def self.check_config config
+    config.each do |k,v|
+      case k
+      when :audio_sample_format
+        raise ConfigError, "#{k} => #{v} is not allowed" unless SAMPLE_FORMATS.include?(v)
+      when :tempo_sample_rate, :audio_sample_rate
+        raise ConfigError, "#{k} => #{v} is not positive" unless v > 0
+      end
+    end
+  end
+
+  def self.load_config project_root_dir
+    globabl_config_path = File.join(project_root_dir,CONFIG_FILE_NAME)
+    
+    config = if File.exists? globabl_config_path
+      global_config = YAML.load(File.read(globabl_config_path))
+      DEFAULT_CONFIG.merge global_config
+    else
+      DEFAULT_CONFIG
+    end
+    check_config config
+    return config
+  end
+end
+
+end

data/lib/musicality/project/project.rb

@@ -0,0 +1,64 @@
+module Musicality
+
+class Project
+  USEFUL_MODULES = ['Musicality','Pitches','Meters','Keys','Articulations','Dynamics']
+
+  attr_reader :dest_dir
+  def initialize dest_dir
+    @dest_dir = dest_dir
+
+    create_project_dir
+    create_gemfile
+    create_rakefile
+    create_config
+    create_scores_dir
+  end
+
+  def create_project_dir
+    if Dir.exists? dest_dir
+      unless Dir.glob(File.join(dest_dir,"*")).empty?
+        raise ArgumentError, "existing directory #{dest_dir} is not empty."
+      end
+    else
+      Dir.mkdir(dest_dir)
+      unless Dir.exists?(dest_dir)
+        raise "directory #{dest_dir} could not be created"
+      end
+    end    
+  end
+
+  def create_gemfile
+    gemfile_path = File.join(dest_dir,"Gemfile")
+    File.open(gemfile_path,"w") do |f|
+      f.puts("source :rubygems")
+      f.puts("gem 'musicality', '~> #{VERSION}'")
+    end
+  end
+
+  def create_rakefile
+    rakefile_path = File.join(dest_dir,"Rakefile")
+    File.open(rakefile_path,"w") do |f|
+      f.puts("require 'musicality'")
+      USEFUL_MODULES.each do |module_name|
+        f.puts("include #{module_name}")
+      end
+      f.puts
+      f.puts("config = Project.load_config(File.dirname(__FILE__))")
+      f.puts("Project.create_tasks(config)")
+    end
+  end
+
+  def create_config
+    config_path = File.join(dest_dir, Project::CONFIG_FILE_NAME)
+    File.open(config_path,"w") do |f|
+      f.write(Project::DEFAULT_CONFIG.to_yaml)
+    end
+  end
+
+  def create_scores_dir
+    scores_dir = File.join(dest_dir, Project::DEFAULT_CONFIG[:scores_dir])
+    Dir.mkdir(scores_dir)
+  end
+end
+
+end