scripts/musicxml2ly.py

   1 #!@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 datadir = '@local_lilypond_datadir@'
  12 if not os.path.isdir (datadir):
  13     datadir = '@lilypond_datadir@'
  14 if os.environ.has_key ('LILYPONDPREFIX'):
  15     datadir = os.environ['LILYPONDPREFIX']
  16     while datadir[-1] == os.sep:
  17         datadir = datadir[:-1]
  18
  19 if os.path.exists (os.path.join (datadir, 'share/lilypond/@TOPLEVEL_VERSION@/')):
  20     datadir = os.path.join (datadir, 'share/lilypond/@TOPLEVEL_VERSION@/')
  21 elif os.path.exists (os.path.join (datadir, 'share/lilypond/current/')):
  22     datadir = os.path.join (datadir, 'share/lilypond/current/')
  23
  24 sys.path.insert (0, os.path.join (datadir, 'python'))
  25
  26 # dynamic relocation, for GUB binaries.
  27 bindir = os.path.split (sys.argv[0])[0]
  28
  29 for prefix_component in ['share', 'lib']:
  30     datadir = os.path.abspath (bindir + '/../%s/lilypond/current/python/' % prefix_component)
  31     sys.path.insert (0, datadir)
  32
  33
  34
  35 import musicxml
  36 import musicexp
  37 import lilylib as ly
  38
  39 from rational import Rational
  40
  41
  42 def progress (str):
  43     sys.stderr.write (str + '\n')
  44     sys.stderr.flush ()
  45
  46
  47 def musicxml_duration_to_lily (mxl_note):
  48     d = musicexp.Duration ()
  49     if mxl_note.get_maybe_exist_typed_child (musicxml.Type):
  50         d.duration_log = mxl_note.get_duration_log ()
  51     else:
  52         d.duration_log = 0
  53
  54     d.dots = len (mxl_note.get_typed_children (musicxml.Dot))
  55     d.factor = mxl_note._duration / d.get_length ()
  56
  57     return d
  58
  59 def group_tuplets (music_list, events):
  60
  61
  62     """Collect Musics from
  63     MUSIC_LIST demarcated by EVENTS_LIST in TimeScaledMusic objects.
  64     """
  65
  66
  67     indices = []
  68
  69     j = 0
  70     for (ev_chord, tuplet_elt, fraction) in events:
  71         while (j < len (music_list)):
  72             if music_list[j]== ev_chord:
  73                 break
  74             j += 1
  75         if tuplet_elt.type == 'start':
  76             indices.append ((j, None, fraction))
  77         elif tuplet_elt.type == 'stop':
  78             indices[-1] = (indices[-1][0], j, indices[-1][2])
  79
  80     new_list = []
  81     last = 0
  82     for (i1, i2, frac) in indices:
  83         if i1 >= i2:
  84             continue
  85
  86         new_list.extend (music_list[last:i1])
  87         seq = musicexp.SequentialMusic ()
  88         last = i2 + 1
  89         seq.elements = music_list[i1:last]
  90
  91         tsm = musicexp.TimeScaledMusic ()
  92         tsm.element = seq
  93
  94         tsm.numerator = frac[0]
  95         tsm.denominator  = frac[1]
  96
  97         new_list.append (tsm)
  98
  99     new_list.extend (music_list[last:])
 100     return new_list
 101
 102
 103 def musicxml_clef_to_lily (mxl):
 104     sign = mxl.get_maybe_exist_named_child ('sign')
 105     change = musicexp.ClefChange ()
 106     if sign:
 107         change.type = sign.get_text ()
 108     return change
 109
 110
 111 def musicxml_time_to_lily (mxl):
 112     beats = mxl.get_maybe_exist_named_child ('beats')
 113     type = mxl.get_maybe_exist_named_child ('beat-type')
 114     change = musicexp.TimeSignatureChange()
 115     change.fraction = (string.atoi(beats.get_text ()),
 116              string.atoi(type.get_text ()))
 117
 118     return change
 119
 120 def musicxml_key_to_lily (mxl):
 121     start_pitch  = musicexp.Pitch ()
 122     try:
 123         mode = mxl.get_maybe_exist_named_child ('mode')
 124         if mode:
 125             mode = mode.get_text ()
 126         else:
 127             mode = 'major'
 128
 129         (n,a) = { 'major' : (0,0),
 130              'minor' : (6,0),
 131             }[mode]
 132         start_pitch.step = n
 133         start_pitch.alteration = a
 134     except  KeyError:
 135         print 'unknown mode', mode
 136
 137     fifths = string.atoi (mxl.get_maybe_exist_named_child ('fifths').get_text ())
 138
 139     fifth = musicexp.Pitch()
 140     fifth.step = 4
 141     if fifths < 0:
 142         fifths *= -1
 143         fifth.step *= -1
 144         fifth.normalize ()
 145
 146     start_pitch = musicexp.Pitch()
 147     for x in range (fifths):
 148         start_pitch = start_pitch.transposed (fifth)
 149
 150     start_pitch.octave = 0
 151
 152     change = musicexp.KeySignatureChange()
 153     change.mode = mode
 154     change.tonic = start_pitch
 155     return change
 156
 157 def musicxml_attributes_to_lily (attrs):
 158     elts = []
 159     attr_dispatch =  {
 160         'clef': musicxml_clef_to_lily,
 161         'time': musicxml_time_to_lily,
 162         'key': musicxml_key_to_lily
 163     }
 164     for (k, func) in attr_dispatch.items ():
 165         childs = attrs.get_named_children (k)
 166
 167         ## ugh: you get clefs spread over staves for piano
 168         if childs:
 169             elts.append (func (childs[0]))
 170
 171     return elts
 172
 173 def create_skip_music (duration):
 174     skip = musicexp.SkipEvent()
 175     skip.duration.duration_log = 0
 176     skip.duration.factor = duration
 177
 178     evc = musicexp.EventChord ()
 179     evc.append (skip)
 180     return evc
 181
 182 spanner_event_dict = {
 183     'slur' : musicexp.SlurEvent,
 184     'beam' : musicexp.BeamEvent,
 185 }
 186 spanner_type_dict = {
 187     'start': -1,
 188     'begin': -1,
 189     'stop': 1,
 190     'end' : 1
 191 }
 192
 193 def musicxml_spanner_to_lily_event (mxl_event):
 194     ev = None
 195
 196     name = mxl_event.get_name()
 197     try:
 198         func = spanner_event_dict[name]
 199         ev = func()
 200     except KeyError:
 201         print 'unknown span event ', mxl_event
 202
 203     try:
 204         key = mxl_event.get_type ()
 205         ev.span_direction = spanner_type_dict[key]
 206     except KeyError:
 207         print 'unknown span type', key, 'for', name
 208
 209     return ev
 210
 211 def musicxml_note_to_lily_main_event (n):
 212     pitch  = None
 213     duration = None
 214
 215     mxl_pitch = n.get_maybe_exist_typed_child (musicxml.Pitch)
 216     event = None
 217     if mxl_pitch:
 218         pitch = musicxml_pitch_to_lily (mxl_pitch)
 219         event = musicexp.NoteEvent()
 220         event.pitch = pitch
 221
 222         acc = n.get_maybe_exist_named_child ('accidental')
 223         if acc:
 224             # let's not force accs everywhere.
 225             event.cautionary = acc.editorial
 226
 227     elif n.get_maybe_exist_typed_child (musicxml.Rest):
 228         event = musicexp.RestEvent()
 229
 230     event.duration = musicxml_duration_to_lily (n)
 231     return event
 232
 233 def musicxml_voice_to_lily_voice (voice):
 234     ly_voice = []
 235     ly_now = Rational (0)
 236     pending_skip = Rational (0)
 237
 238     tuplet_events = []
 239
 240     for n in voice._elements:
 241         if n.get_name () == 'forward':
 242             continue
 243
 244         if isinstance (n, musicxml.Attributes):
 245             ly_now += pending_skip
 246             pending_skip = Rational (0)
 247
 248             ly_voice.extend (musicxml_attributes_to_lily (n))
 249             continue
 250
 251         if not n.__class__.__name__ == 'Note':
 252             print 'not a Note or Attributes?', n
 253             continue
 254
 255         if n.is_first () and ly_voice:
 256             ly_voice[-1].comment += '\n'
 257
 258
 259         main_event = musicxml_note_to_lily_main_event (n)
 260
 261         ev_chord = None
 262         if None ==  n.get_maybe_exist_typed_child (musicxml.Chord):
 263             ly_now += pending_skip
 264             pending_skip = main_event.get_length ()
 265
 266             if ly_now <> n._when:
 267                 diff = n._when - ly_now
 268
 269                 if diff < Rational (0):
 270                     print 'huh: negative skip', n._when, ly_now, n._duration
 271                     diff = Rational (1,314159265)
 272
 273                 ly_voice.append (create_skip_music (diff))
 274                 ly_now = n._when
 275
 276             ly_voice.append (musicexp.EventChord())
 277         else:
 278             pass
 279
 280         ev_chord = ly_voice[-1]
 281         ev_chord.append (main_event)
 282
 283         notations = n.get_maybe_exist_typed_child (musicxml.Notations)
 284         tuplet_event = None
 285         span_events = []
 286         if notations:
 287             if notations.get_tuplet():
 288                 tuplet_event = notations.get_tuplet()
 289                 mod = n.get_maybe_exist_typed_child (musicxml.Time_modification)
 290                 frac = (1,1)
 291                 if mod:
 292                     frac = mod.get_fraction ()
 293
 294                 tuplet_events.append ((ev_chord, tuplet_event, frac))
 295
 296             slurs = [s for s in notations.get_named_children ('slur')
 297                 if s.get_type () in ('start','stop')]
 298             if slurs:
 299                 if len (slurs) > 1:
 300                     print 'more than 1 slur?'
 301
 302                 lily_ev = musicxml_spanner_to_lily_event (slurs[0])
 303                 ev_chord.append (lily_ev)
 304
 305             mxl_tie = notations.get_tie ()
 306             if mxl_tie and mxl_tie.type == 'start':
 307                 ev_chord.append (musicexp.TieEvent ())
 308
 309         mxl_beams = [b for b in n.get_named_children ('beam')
 310               if b.get_type () in ('begin', 'end')]
 311         if mxl_beams:
 312             beam_ev = musicxml_spanner_to_lily_event (mxl_beams[0])
 313             if beam_ev:
 314                 ev_chord.append (beam_ev)
 315
 316         if tuplet_event:
 317             mod = n.get_maybe_exist_typed_child (musicxml.Time_modification)
 318             frac = (1,1)
 319             if mod:
 320                 frac = mod.get_fraction ()
 321
 322             tuplet_events.append ((ev_chord, tuplet_event, frac))
 323
 324     ly_voice = group_tuplets (ly_voice, tuplet_events)
 325
 326     seq_music = musicexp.SequentialMusic()
 327
 328     seq_music.elements = ly_voice
 329     return seq_music
 330
 331
 332 def musicxml_id_to_lily (id):
 333     digits = ['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight',
 334          'nine', 'ten']
 335
 336     for dig in digits:
 337         d = digits.index (dig) + 1
 338         dig = dig[0].upper() + dig[1:]
 339         id = re.sub ('%d' % d, dig, id)
 340
 341     id = re.sub  ('[^a-zA-Z]', 'X', id)
 342     return id
 343
 344
 345 def musicxml_pitch_to_lily (mxl_pitch):
 346     p = musicexp.Pitch()
 347     p.alteration = mxl_pitch.get_alteration ()
 348     p.step = (ord (mxl_pitch.get_step ()) - ord ('A') + 7 - 2) % 7
 349     p.octave = mxl_pitch.get_octave () - 4
 350     return p
 351
 352
 353
 354 def voices_in_part (part):
 355     """Return a Name -> Voice dictionary for PART"""
 356     part.interpret ()
 357     part.extract_voices ()
 358     voice_dict = part.get_voices ()
 359
 360     return voice_dict
 361
 362 def voices_in_part_in_parts (parts):
 363     """return a Part -> Name -> Voice dictionary"""
 364     return dict([(p, voices_in_part (p)) for p in parts])
 365
 366
 367 def get_all_voices (parts):
 368     all_voices = voices_in_part_in_parts (parts)
 369
 370     all_ly_voices = {}
 371     for p, name_voice in all_voices.items ():
 372
 373         part_ly_voices = {}
 374         for n, v in name_voice.items ():
 375             progress ("Converting to LilyPond expressions...")
 376             part_ly_voices[n] = (musicxml_voice_to_lily_voice (v), v)
 377
 378         all_ly_voices[p] = part_ly_voices
 379
 380     return all_ly_voices
 381
 382
 383 def option_parser ():
 384     p = ly.get_option_parser(usage='musicxml2ly FILE.xml',
 385                  version = """%prog (LilyPond) @TOPLEVEL_VERSION@
 386
 387 This program is free software.  It is covered by the GNU General Public
 388 License and you are welcome to change it and/or distribute copies of it
 389 under certain conditions.  Invoke as `lilypond --warranty' for more
 390 information.
 391
 392 Copyright (c) 2005--2006 by
 393  Han-Wen Nienhuys <hanwen@xs4all.nl> and
 394  Jan Nieuwenhuizen <janneke@gnu.org>
 395 """,
 396
 397                  description  =
 398                  """Convert MusicXML file to LilyPond input.
 399 """
 400                  )
 401     p.add_option ('-v', '--verbose',
 402            action = "store_true",
 403            dest = 'verbose',
 404            help = 'be verbose')
 405     p.add_option ('-o', '--output',
 406            metavar = 'FILE',
 407            action = "store",
 408            default = None,
 409            type = 'string',
 410            dest = 'output',
 411            help = 'set output file')
 412
 413     p.add_option_group  ('', description = '''Report bugs via http://post.gmane.org/post.php?group=gmane.comp.gnu.lilypond.bugs
 414 ''')
 415     return p
 416
 417 def music_xml_voice_name_to_lily_name (part, name):
 418     str = "Part%sVoice%s" % (part.id, name)
 419     return musicxml_id_to_lily (str)
 420
 421 def print_voice_definitions (printer, voices):
 422     for (part, nv_dict) in voices.items():
 423         for (name, (voice, mxlvoice)) in nv_dict.items ():
 424             k = music_xml_voice_name_to_lily_name (part, name)
 425             printer.dump ('%s = ' % k)
 426             voice.print_ly (printer)
 427             printer.newline()
 428 def uniq_list (l):
 429     return dict ([(elt,1) for elt in l]).keys ()
 430
 431 def print_score_setup (printer, part_list, voices):
 432     part_dict = dict ([(p.id, p) for p in voices.keys ()])
 433
 434     printer ('<<')
 435     printer.newline ()
 436     for part_definition in part_list:
 437         part_name = part_definition.id
 438         try:
 439             part = part_dict[part_name]
 440         except KeyError:
 441             print 'unknown part in part-list:', part_name
 442             continue
 443
 444         nv_dict = voices[part]
 445         staves = reduce (lambda x,y: x+ y,
 446                 [mxlvoice._staves.keys ()
 447                  for (v, mxlvoice) in nv_dict.values ()],
 448                 [])
 449
 450         if len (staves) > 1:
 451             staves = uniq_list (staves)
 452             staves.sort ()
 453             printer ('\\context PianoStaff << ')
 454             printer.newline ()
 455
 456             for s in staves:
 457                 staff_voices = [music_xml_voice_name_to_lily_name (part, voice_name)
 458                         for (voice_name, (v, mxlvoice)) in nv_dict.items ()
 459                         if mxlvoice._start_staff == s]
 460
 461                 printer ('\\context Staff = "%s" << ' % s)
 462                 printer.newline ()
 463                 for v in staff_voices:
 464                     printer ('\\context Voice = "%s"  \\%s' % (v,v))
 465                     printer.newline ()
 466                 printer ('>>')
 467                 printer.newline ()
 468
 469             printer ('>>')
 470             printer.newline ()
 471
 472         else:
 473             printer ('\\new Staff <<')
 474             printer.newline ()
 475             for (n,v) in nv_dict.items ():
 476
 477                 n = music_xml_voice_name_to_lily_name (part, n)
 478                 printer ('\\context Voice = "%s"  \\%s' % (n,n))
 479             printer ('>>')
 480             printer.newline ()
 481
 482
 483     printer ('>>')
 484     printer.newline ()
 485
 486
 487
 488 def print_ly_preamble (printer, filename):
 489     printer.dump_version ()
 490     printer.print_verbatim ('%% converted from %s\n' % filename)
 491
 492 def convert (filename, output_name):
 493     printer = musicexp.Output_printer()
 494     progress ("Reading MusicXML...")
 495
 496     tree = musicxml.read_musicxml (filename)
 497     parts = tree.get_typed_children (musicxml.Part)
 498     voices = get_all_voices (parts)
 499
 500     part_list = []
 501     if tree.get_maybe_exist_typed_child (musicxml.Part_list):
 502         pl = tree.get_maybe_exist_typed_child (musicxml.Part_list)
 503         part_list = pl.get_named_children ("score-part")
 504
 505     if not output_name:
 506         output_name = os.path.basename (filename)
 507         output_name = os.path.splitext (output_name)[0] + '.ly'
 508
 509
 510     if output_name:
 511         progress ("Output to `%s'" % output_name)
 512         printer.set_file (open (output_name, 'w'))
 513
 514     progress ("Printing as .ly...")
 515
 516     print_ly_preamble (printer, filename)
 517     print_voice_definitions (printer,  voices)
 518     print_score_setup (printer, part_list, voices)
 519     printer.newline ()
 520     return voices
 521
 522
 523 def main ():
 524     opt_parser = option_parser()
 525
 526     (options, args) = opt_parser.parse_args ()
 527     if not args:
 528         opt_parser.print_usage()
 529         sys.exit (2)
 530
 531     voices = convert (args[0], options.output)
 532
 533 if __name__ == '__main__':
 534     main()