scripts/musicxml2ly.py

   1 #!@TARGET_PYTHON@
   2
   3 import optparse
   4 import sys
   5 import re
   6 import os
   7 import string
   8 from gettext import gettext as _
   9
  10
  11
  12 for d in ['@lilypond_datadir@',
  13           '@lilypond_libdir@']:
  14     sys.path.insert (0, os.path.join (d, 'python'))
  15
  16 # dynamic relocation, for GUB binaries.
  17 bindir = os.path.abspath (os.path.split (sys.argv[0])[0])
  18 for p in ['share', 'lib']:
  19     datadir = os.path.abspath (bindir + '/../%s/lilypond/current/python/' % p)
  20     sys.path.insert (0, datadir)
  21
  22
  23
  24
  25 import lilylib as ly
  26
  27 import musicxml
  28 import musicexp
  29
  30 from rational import Rational
  31
  32
  33 def progress (str):
  34     sys.stderr.write (str + '\n')
  35     sys.stderr.flush ()
  36
  37
  38 def musicxml_duration_to_lily (mxl_note):
  39     d = musicexp.Duration ()
  40     if mxl_note.get_maybe_exist_typed_child (musicxml.Type):
  41         d.duration_log = mxl_note.get_duration_log ()
  42     else:
  43         d.duration_log = 0
  44
  45     d.dots = len (mxl_note.get_typed_children (musicxml.Dot))
  46     d.factor = mxl_note._duration / d.get_length ()
  47
  48     return d
  49
  50 def group_tuplets (music_list, events):
  51
  52
  53     """Collect Musics from
  54     MUSIC_LIST demarcated by EVENTS_LIST in TimeScaledMusic objects.
  55     """
  56
  57
  58     indices = []
  59
  60     j = 0
  61     for (ev_chord, tuplet_elt, fraction) in events:
  62         while (j < len (music_list)):
  63             if music_list[j]== ev_chord:
  64                 break
  65             j += 1
  66         if tuplet_elt.type == 'start':
  67             indices.append ((j, None, fraction))
  68         elif tuplet_elt.type == 'stop':
  69             indices[-1] = (indices[-1][0], j, indices[-1][2])
  70
  71     new_list = []
  72     last = 0
  73     for (i1, i2, frac) in indices:
  74         if i1 >= i2:
  75             continue
  76
  77         new_list.extend (music_list[last:i1])
  78         seq = musicexp.SequentialMusic ()
  79         last = i2 + 1
  80         seq.elements = music_list[i1:last]
  81
  82         tsm = musicexp.TimeScaledMusic ()
  83         tsm.element = seq
  84
  85         tsm.numerator = frac[0]
  86         tsm.denominator  = frac[1]
  87
  88         new_list.append (tsm)
  89
  90     new_list.extend (music_list[last:])
  91     return new_list
  92
  93
  94 def musicxml_clef_to_lily (attributes):
  95     change = musicexp.ClefChange ()
  96     change.type = attributes.get_clef_sign ()
  97     return change
  98
  99 def musicxml_time_to_lily (attributes):
 100     (beats, type) = attributes.get_time_signature ()
 101
 102     change = musicexp.TimeSignatureChange()
 103     change.fraction = (beats, type)
 104
 105     return change
 106
 107 def musicxml_key_to_lily (attributes):
 108     start_pitch  = musicexp.Pitch ()
 109     (fifths, mode) = attributes.get_key_signature ()
 110     try:
 111         (n,a) = {
 112             'major' : (0,0),
 113             'minor' : (5,0),
 114             }[mode]
 115         start_pitch.step = n
 116         start_pitch.alteration = a
 117     except  KeyError:
 118         print 'unknown mode', mode
 119
 120     fifth = musicexp.Pitch()
 121     fifth.step = 4
 122     if fifths < 0:
 123         fifths *= -1
 124         fifth.step *= -1
 125         fifth.normalize ()
 126
 127     for x in range (fifths):
 128         start_pitch = start_pitch.transposed (fifth)
 129
 130     start_pitch.octave = 0
 131
 132     change = musicexp.KeySignatureChange()
 133     change.mode = mode
 134     change.tonic = start_pitch
 135     return change
 136
 137 def musicxml_attributes_to_lily (attrs):
 138     elts = []
 139     attr_dispatch =  {
 140         'clef': musicxml_clef_to_lily,
 141         'time': musicxml_time_to_lily,
 142         'key': musicxml_key_to_lily
 143     }
 144     for (k, func) in attr_dispatch.items ():
 145         childs = attrs.get_named_children (k)
 146
 147         ## ugh: you get clefs spread over staves for piano
 148         if childs:
 149             elts.append (func (attrs))
 150
 151     return elts
 152
 153 spanner_event_dict = {
 154     'slur' : musicexp.SlurEvent,
 155     'beam' : musicexp.BeamEvent,
 156 }
 157 spanner_type_dict = {
 158     'start': -1,
 159     'begin': -1,
 160     'stop': 1,
 161     'end' : 1
 162 }
 163
 164 def musicxml_spanner_to_lily_event (mxl_event):
 165     ev = None
 166
 167     name = mxl_event.get_name()
 168     try:
 169         func = spanner_event_dict[name]
 170         ev = func()
 171     except KeyError:
 172         print 'unknown span event ', mxl_event
 173
 174     try:
 175         key = mxl_event.get_type ()
 176         ev.span_direction = spanner_type_dict[key]
 177     except KeyError:
 178         print 'unknown span type', key, 'for', name
 179
 180     return ev
 181
 182 instrument_drumtype_dict = {
 183     'Acoustic Snare Drum': 'acousticsnare',
 184     'Side Stick': 'sidestick',
 185     'Open Triangle': 'opentriangle',
 186     'Mute Triangle': 'mutetriangle',
 187     'Tambourine': 'tambourine',
 188
 189 }
 190
 191 def musicxml_note_to_lily_main_event (n):
 192     pitch  = None
 193     duration = None
 194
 195     mxl_pitch = n.get_maybe_exist_typed_child (musicxml.Pitch)
 196     event = None
 197     if mxl_pitch:
 198         pitch = musicxml_pitch_to_lily (mxl_pitch)
 199         event = musicexp.NoteEvent()
 200         event.pitch = pitch
 201
 202         acc = n.get_maybe_exist_named_child ('accidental')
 203         if acc:
 204             # let's not force accs everywhere.
 205             event.cautionary = acc.editorial
 206
 207     elif n.get_maybe_exist_typed_child (musicxml.Rest):
 208         event = musicexp.RestEvent()
 209     elif n.instrument_name:
 210         event = musicexp.NoteEvent ()
 211         event.drum_type = instrument_drumtype_dict[n.instrument_name]
 212
 213
 214     if not event:
 215         n.message ("could not find suitable event")
 216
 217     event.duration = musicxml_duration_to_lily (n)
 218     return event
 219
 220
 221 ## todo
 222 class NegativeSkip:
 223     def __init__ (self, here, dest):
 224         self.here = here
 225         self.dest = dest
 226
 227 class LilyPondVoiceBuilder:
 228     def __init__ (self):
 229         self.elements = []
 230         self.end_moment = Rational (0)
 231         self.begin_moment = Rational (0)
 232         self.pending_multibar = Rational (0)
 233
 234     def _insert_multibar (self):
 235         r = musicexp.MultiMeasureRest ()
 236         r.duration = musicexp.Duration()
 237         r.duration.duration_log = 0
 238         r.duration.factor = self.pending_multibar
 239         self.elements.append (r)
 240         self.begin_moment = self.end_moment
 241         self.end_moment = self.begin_moment + self.pending_multibar
 242         self.pending_multibar = Rational (0)
 243
 244     def add_multibar_rest (self, duration):
 245         self.pending_multibar += duration
 246
 247
 248     def add_music (self, music, duration):
 249         assert isinstance (music, musicexp.Music)
 250         if self.pending_multibar > Rational (0):
 251             self._insert_multibar ()
 252
 253         self.elements.append (music)
 254         self.begin_moment = self.end_moment
 255         self.end_moment = self.begin_moment + duration
 256
 257     def add_bar_check (self, number):
 258         b = musicexp.BarCheck ()
 259         b.bar_number = number
 260         self.add_music (b, Rational (0))
 261
 262     def jumpto (self, moment):
 263         current_end = self.end_moment + self.pending_multibar
 264         diff = moment - current_end
 265
 266         if diff < Rational (0):
 267             raise NegativeSkip(current_end, moment)
 268
 269         if diff > Rational (0):
 270             skip = musicexp.SkipEvent()
 271             skip.duration.duration_log = 0
 272             skip.duration.factor = diff
 273
 274             evc = musicexp.EventChord ()
 275             evc.elements.append (skip)
 276             self.add_music (evc, diff)
 277
 278     def last_event_chord (self, starting_at):
 279
 280         value = None
 281         if (self.elements
 282             and isinstance (self.elements[-1], musicexp.EventChord)
 283             and self.begin_moment == starting_at):
 284             value = self.elements[-1]
 285         else:
 286             self.jumpto (starting_at)
 287             value = None
 288
 289         return value
 290
 291     def correct_negative_skip (self, goto):
 292         self.end_moment = goto
 293         self.begin_moment = goto
 294         evc = musicexp.EventChord ()
 295         self.elements.append (evc)
 296
 297 def musicxml_voice_to_lily_voice (voice):
 298     tuplet_events = []
 299     modes_found = {}
 300
 301     voice_builder = LilyPondVoiceBuilder()
 302
 303     for n in voice._elements:
 304         if n.get_name () == 'forward':
 305             continue
 306
 307         if not n.get_maybe_exist_named_child ('chord'):
 308             try:
 309                 voice_builder.jumpto (n._when)
 310             except NegativeSkip, neg:
 311                 voice_builder.correct_negative_skip (n._when)
 312                 n.message ("Negative skip? from %s to %s, diff %s" % (neg.here, neg.dest, neg.dest - neg.here))
 313
 314         if isinstance (n, musicxml.Attributes):
 315             if n.is_first () and n._measure_position == Rational (0):
 316                 voice_builder.add_bar_check (int (n.get_parent ().number))
 317             for a in musicxml_attributes_to_lily (n):
 318                 voice_builder.add_music (a, Rational (0))
 319             continue
 320
 321         if not n.__class__.__name__ == 'Note':
 322             print 'not a Note or Attributes?', n
 323             continue
 324
 325         rest = n.get_maybe_exist_typed_child (musicxml.Rest)
 326         if (rest
 327             and rest.is_whole_measure ()):
 328
 329             voice_builder.add_multibar_rest (n._duration)
 330             continue
 331
 332         if n.is_first () and n._measure_position == Rational (0):
 333             num = int (n.get_parent ().number)
 334             voice_builder.add_bar_check (num)
 335
 336         main_event = musicxml_note_to_lily_main_event (n)
 337
 338         try:
 339             if main_event.drum_type:
 340                 modes_found['drummode'] = True
 341         except AttributeError:
 342             pass
 343
 344
 345         ev_chord = voice_builder.last_event_chord (n._when)
 346         if not ev_chord:
 347             ev_chord = musicexp.EventChord()
 348             voice_builder.add_music (ev_chord, n._duration)
 349
 350         ev_chord.append (main_event)
 351
 352         notations = n.get_maybe_exist_typed_child (musicxml.Notations)
 353         tuplet_event = None
 354         span_events = []
 355         if notations:
 356             if notations.get_tuplet():
 357                 tuplet_event = notations.get_tuplet()
 358                 mod = n.get_maybe_exist_typed_child (musicxml.Time_modification)
 359                 frac = (1,1)
 360                 if mod:
 361                     frac = mod.get_fraction ()
 362
 363                 tuplet_events.append ((ev_chord, tuplet_event, frac))
 364
 365             slurs = [s for s in notations.get_named_children ('slur')
 366                 if s.get_type () in ('start','stop')]
 367             if slurs:
 368                 if len (slurs) > 1:
 369                     print 'more than 1 slur?'
 370
 371                 lily_ev = musicxml_spanner_to_lily_event (slurs[0])
 372                 ev_chord.append (lily_ev)
 373
 374             mxl_tie = notations.get_tie ()
 375             if mxl_tie and mxl_tie.type == 'start':
 376                 ev_chord.append (musicexp.TieEvent ())
 377
 378         mxl_beams = [b for b in n.get_named_children ('beam')
 379                      if (b.get_type () in ('begin', 'end')
 380                          and b.is_primary ())]
 381         if mxl_beams:
 382             beam_ev = musicxml_spanner_to_lily_event (mxl_beams[0])
 383             if beam_ev:
 384                 ev_chord.append (beam_ev)
 385
 386         if tuplet_event:
 387             mod = n.get_maybe_exist_typed_child (musicxml.Time_modification)
 388             frac = (1,1)
 389             if mod:
 390                 frac = mod.get_fraction ()
 391
 392             tuplet_events.append ((ev_chord, tuplet_event, frac))
 393
 394     ## force trailing mm rests to be written out.
 395     voice_builder.add_music (musicexp.EventChord (), Rational (0))
 396
 397     ly_voice = group_tuplets (voice_builder.elements, tuplet_events)
 398
 399     seq_music = musicexp.SequentialMusic()
 400
 401     if 'drummode' in modes_found.keys ():
 402         ## \key <pitch> barfs in drummode.
 403         ly_voice = [e for e in ly_voice
 404                     if not isinstance(e, musicexp.KeySignatureChange)]
 405
 406     seq_music.elements = ly_voice
 407
 408
 409
 410     if len (modes_found) > 1:
 411        print 'Too many modes found', modes_found.keys ()
 412
 413     return_value = seq_music
 414     for mode in modes_found.keys ():
 415         v = musicexp.ModeChangingMusicWrapper()
 416         v.element = return_value
 417         v.mode = mode
 418         return_value = v
 419
 420     return return_value
 421
 422
 423 def musicxml_id_to_lily (id):
 424     digits = ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight',
 425               'nine', 'ten']
 426
 427     for dig in digits:
 428         d = digits.index (dig) + 1
 429         dig = dig[0].upper() + dig[1:]
 430         id = re.sub ('%d' % d, dig, id)
 431
 432     id = re.sub  ('[^a-zA-Z]', 'X', id)
 433     return id
 434
 435
 436 def musicxml_pitch_to_lily (mxl_pitch):
 437     p = musicexp.Pitch()
 438     p.alteration = mxl_pitch.get_alteration ()
 439     p.step = (ord (mxl_pitch.get_step ()) - ord ('A') + 7 - 2) % 7
 440     p.octave = mxl_pitch.get_octave () - 4
 441     return p
 442
 443 def voices_in_part (part):
 444     """Return a Name -> Voice dictionary for PART"""
 445     part.interpret ()
 446     part.extract_voices ()
 447     voice_dict = part.get_voices ()
 448
 449     return voice_dict
 450
 451 def voices_in_part_in_parts (parts):
 452     """return a Part -> Name -> Voice dictionary"""
 453     return dict([(p, voices_in_part (p)) for p in parts])
 454
 455
 456 def get_all_voices (parts):
 457     all_voices = voices_in_part_in_parts (parts)
 458
 459     all_ly_voices = {}
 460     for p, name_voice in all_voices.items ():
 461
 462         part_ly_voices = {}
 463         for n, v in name_voice.items ():
 464             progress ("Converting to LilyPond expressions...")
 465             part_ly_voices[n] = (musicxml_voice_to_lily_voice (v), v)
 466
 467         all_ly_voices[p] = part_ly_voices
 468
 469     return all_ly_voices
 470
 471
 472 def option_parser ():
 473     p = ly.get_option_parser(usage='musicxml2ly FILE.xml',
 474                  version = """%prog (LilyPond) @TOPLEVEL_VERSION@
 475
 476 This program is free software.  It is covered by the GNU General Public
 477 License and you are welcome to change it and/or distribute copies of it
 478 under certain conditions.  Invoke as `lilypond --warranty' for more
 479 information.
 480
 481 Copyright (c) 2005--2006 by
 482     Han-Wen Nienhuys <hanwen@xs4all.nl> and
 483     Jan Nieuwenhuizen <janneke@gnu.org>
 484 """,
 485
 486                  description  =
 487                  """Convert MusicXML file to LilyPond input.
 488 """
 489                  )
 490     p.add_option ('-v', '--verbose',
 491                   action = "store_true",
 492                   dest = 'verbose',
 493                   help = 'be verbose')
 494
 495     p.add_option ('', '--lxml',
 496                   action="store_true",
 497                   default=False,
 498                   dest="use_lxml",
 499                   help="Use lxml.etree; uses less memory and cpu time.")
 500
 501     p.add_option ('-o', '--output',
 502                   metavar = 'FILE',
 503                   action="store",
 504                   default=None,
 505                   type='string',
 506                   dest='output_name',
 507                   help='set output file')
 508
 509     p.add_option_group  ('', description = '''Report bugs via http://post.gmane.org/post.php?group=gmane.comp.gnu.lilypond.bugs
 510 ''')
 511     return p
 512
 513 def music_xml_voice_name_to_lily_name (part, name):
 514     str = "Part%sVoice%s" % (part.id, name)
 515     return musicxml_id_to_lily (str)
 516
 517 def print_voice_definitions (printer, voices):
 518     for (part, nv_dict) in voices.items():
 519
 520         for (name, (voice, mxlvoice)) in nv_dict.items ():
 521             k = music_xml_voice_name_to_lily_name (part, name)
 522             printer.dump ('%s = ' % k)
 523             voice.print_ly (printer)
 524             printer.newline()
 525
 526
 527 def uniq_list (l):
 528     return dict ([(elt,1) for elt in l]).keys ()
 529
 530 def print_score_setup (printer, part_list, voices):
 531     part_dict = dict ([(p.id, p) for p in voices.keys ()])
 532
 533     printer ('<<')
 534     printer.newline ()
 535     for part_definition in part_list:
 536         part_name = part_definition.id
 537         try:
 538             part = part_dict[part_name]
 539         except KeyError:
 540             print 'unknown part in part-list:', part_name
 541             continue
 542
 543         nv_dict = voices[part]
 544         staves = reduce (lambda x,y: x+ y,
 545                 [mxlvoice._staves.keys ()
 546                  for (v, mxlvoice) in nv_dict.values ()],
 547                 [])
 548
 549         if len (staves) > 1:
 550             staves = uniq_list (staves)
 551             staves.sort ()
 552             printer ('\\context PianoStaff << ')
 553             printer.newline ()
 554
 555             for s in staves:
 556                 staff_voices = [music_xml_voice_name_to_lily_name (part, voice_name)
 557                         for (voice_name, (v, mxlvoice)) in nv_dict.items ()
 558                         if mxlvoice._start_staff == s]
 559
 560                 printer ('\\context Staff = "%s" << ' % s)
 561                 printer.newline ()
 562                 for v in staff_voices:
 563                     printer ('\\context Voice = "%s"  \\%s' % (v,v))
 564                     printer.newline ()
 565                 printer ('>>')
 566                 printer.newline ()
 567
 568             printer ('>>')
 569             printer.newline ()
 570
 571         else:
 572             printer ('\\new Staff <<')
 573             printer.newline ()
 574             for (n,v) in nv_dict.items ():
 575
 576                 n = music_xml_voice_name_to_lily_name (part, n)
 577                 printer ('\\context Voice = "%s"  \\%s' % (n,n))
 578             printer ('>>')
 579             printer.newline ()
 580
 581     printer ('>>')
 582     printer.newline ()
 583
 584 def print_ly_preamble (printer, filename):
 585     printer.dump_version ()
 586     printer.print_verbatim ('%% converted from %s\n' % filename)
 587
 588 def read_musicxml (filename, use_lxml):
 589     if use_lxml:
 590         import lxml.etree
 591
 592         tree = lxml.etree.parse (filename)
 593         mxl_tree = musicxml.lxml_demarshal_node (tree.getroot ())
 594         return mxl_tree
 595     else:
 596         from xml.dom import minidom, Node
 597
 598         doc = minidom.parse(filename)
 599         node = doc.documentElement
 600         return musicxml.minidom_demarshal_node (node)
 601
 602     return None
 603
 604
 605 def convert (filename, options):
 606     progress ("Reading MusicXML from %s ..." % filename)
 607
 608     tree = read_musicxml (filename, options.use_lxml)
 609
 610     part_list = []
 611     id_instrument_map = {}
 612     if tree.get_maybe_exist_typed_child (musicxml.Part_list):
 613         mxl_pl = tree.get_maybe_exist_typed_child (musicxml.Part_list)
 614         part_list = mxl_pl.get_named_children ("score-part")
 615
 616     parts = tree.get_typed_children (musicxml.Part)
 617     voices = get_all_voices (parts)
 618
 619     if not options.output_name:
 620         options.output_name = os.path.basename (filename)
 621         options.output_name = os.path.splitext (options.output_name)[0]
 622
 623
 624     defs_ly_name = options.output_name + '-defs.ly'
 625     driver_ly_name = options.output_name + '.ly'
 626
 627     printer = musicexp.Output_printer()
 628     progress ("Output to `%s'" % defs_ly_name)
 629     printer.set_file (open (defs_ly_name, 'w'))
 630
 631     print_ly_preamble (printer, filename)
 632     print_voice_definitions (printer, voices)
 633
 634     printer.close ()
 635
 636
 637     progress ("Output to `%s'" % driver_ly_name)
 638     printer = musicexp.Output_printer()
 639     printer.set_file (open (driver_ly_name, 'w'))
 640     print_ly_preamble (printer, filename)
 641     printer.dump (r'\include "%s"' % defs_ly_name)
 642     print_score_setup (printer, part_list, voices)
 643     printer.newline ()
 644
 645     return voices
 646
 647
 648 def main ():
 649     opt_parser = option_parser()
 650
 651     (options, args) = opt_parser.parse_args ()
 652     if not args:
 653         opt_parser.print_usage()
 654         sys.exit (2)
 655
 656     voices = convert (args[0], options)
 657
 658 if __name__ == '__main__':
 659     main()