scripts/musicxml2ly.py

   1 #!@TARGET_PYTHON@
   2
   3 import optparse
   4 import sys
   5 import re
   6 import os
   7 import string
   8 import codecs
   9 import zipfile
  10 import StringIO
  11
  12 """
  13 @relocate-preamble@
  14 """
  15
  16 import lilylib as ly
  17 _ = ly._
  18
  19 import musicxml
  20 import musicexp
  21
  22 from rational import Rational
  23
  24 # Store command-line options in a global variable, so we can access them everythwere
  25 options = None
  26
  27 class Conversion_Settings:
  28     def __init__(self):
  29        self.ignore_beaming = False
  30
  31 conversion_settings = Conversion_Settings ()
  32
  33 def progress (str):
  34     ly.stderr_write (str + '\n')
  35     sys.stderr.flush ()
  36
  37 def error_message (str):
  38     ly.stderr_write (str + '\n')
  39     sys.stderr.flush ()
  40
  41 needed_additional_definitions = []
  42 additional_definitions = {
  43   "snappizzicato": """#(define-markup-command (snappizzicato layout props) ()
  44   (interpret-markup layout props
  45     (markup #:stencil
  46       (ly:stencil-translate-axis
  47         (ly:stencil-add
  48           (make-circle-stencil 0.7 0.1 #f)
  49           (ly:make-stencil
  50             (list 'draw-line 0.1 0 0.1 0 1)
  51             '(-0.1 . 0.1) '(0.1 . 1)
  52           )
  53         )
  54         0.7 X
  55       )
  56     )
  57   )
  58 )"""
  59 }
  60
  61 def round_to_two_digits (val):
  62     return round (val * 100) / 100
  63
  64 def extract_layout_information (tree):
  65     paper = musicexp.Paper ()
  66     defaults = tree.get_maybe_exist_named_child ('defaults')
  67     if not defaults:
  68         return None
  69     tenths = -1
  70     scaling = defaults.get_maybe_exist_named_child ('scaling')
  71     if scaling:
  72         mm = scaling.get_named_child ('millimeters')
  73         mm = string.atof (mm.get_text ())
  74         tn = scaling.get_maybe_exist_named_child ('tenths')
  75         tn = string.atof (tn.get_text ())
  76         tenths = mm / tn
  77         paper.global_staff_size = mm * 72.27 / 25.4
  78     # We need the scaling (i.e. the size of staff tenths for everything!
  79     if tenths < 0:
  80         return None
  81
  82     def from_tenths (txt):
  83         return round_to_two_digits (string.atof (txt) * tenths / 10)
  84     def set_paper_variable (varname, parent, element_name):
  85         el = parent.get_maybe_exist_named_child (element_name)
  86         if el: # Convert to cm from tenths
  87             setattr (paper, varname, from_tenths (el.get_text ()))
  88
  89     pagelayout = defaults.get_maybe_exist_named_child ('page-layout')
  90     if pagelayout:
  91         # TODO: How can one have different margins for even and odd pages???
  92         set_paper_variable ("page_height", pagelayout, 'page-height')
  93         set_paper_variable ("page_width", pagelayout, 'page-width')
  94
  95         pmargins = pagelayout.get_named_children ('page-margins')
  96         for pm in pmargins:
  97             set_paper_variable ("left_margin", pm, 'left-margin')
  98             set_paper_variable ("right_margin", pm, 'right-margin')
  99             set_paper_variable ("bottom_margin", pm, 'bottom-margin')
 100             set_paper_variable ("top_margin", pm, 'top-margin')
 101
 102     systemlayout = defaults.get_maybe_exist_named_child ('system-layout')
 103     if systemlayout:
 104         sl = systemlayout.get_maybe_exist_named_child ('system-margins')
 105         if sl:
 106             set_paper_variable ("system_left_margin", sl, 'left-margin')
 107             set_paper_variable ("system_right_margin", sl, 'right-margin')
 108         set_paper_variable ("system_distance", systemlayout, 'system-distance')
 109         set_paper_variable ("top_system_distance", systemlayout, 'top-system-distance')
 110
 111     stafflayout = defaults.get_named_children ('staff-layout')
 112     for sl in stafflayout:
 113         nr = getattr (sl, 'number', 1)
 114         dist = sl.get_named_child ('staff-distance')
 115         #TODO: the staff distance needs to be set in the Staff context!!!
 116
 117     # TODO: Finish appearance?, music-font?, word-font?, lyric-font*, lyric-language*
 118     appearance = defaults.get_named_child ('appearance')
 119     if appearance:
 120         lws = appearance.get_named_children ('line-width')
 121         for lw in lws:
 122             # Possible types are: beam, bracket, dashes,
 123             #    enclosure, ending, extend, heavy barline, leger,
 124             #    light barline, octave shift, pedal, slur middle, slur tip,
 125             #    staff, stem, tie middle, tie tip, tuplet bracket, and wedge
 126             tp = lw.type
 127             w = from_tenths (lw.get_text  ())
 128             # TODO: Do something with these values!
 129         nss = appearance.get_named_children ('note-size')
 130         for ns in nss:
 131             # Possible types are: cue, grace and large
 132             tp = ns.type
 133             sz = from_tenths (ns.get_text ())
 134             # TODO: Do something with these values!
 135         # <other-appearance> elements have no specified meaning
 136
 137     rawmusicfont = defaults.get_named_child ('music-font')
 138     if rawmusicfont:
 139         # TODO: Convert the font
 140         pass
 141     rawwordfont = defaults.get_named_child ('word-font')
 142     if rawwordfont:
 143         # TODO: Convert the font
 144         pass
 145     rawlyricsfonts = defaults.get_named_children ('lyric-font')
 146     for lyricsfont in rawlyricsfonts:
 147         # TODO: Convert the font
 148         pass
 149
 150     return paper
 151
 152
 153
 154 # score information is contained in the <work>, <identification> or <movement-title> tags
 155 # extract those into a hash, indexed by proper lilypond header attributes
 156 def extract_score_information (tree):
 157     header = musicexp.Header ()
 158     def set_if_exists (field, value):
 159         if value:
 160             header.set_field (field, musicxml.escape_ly_output_string (value))
 161
 162     work = tree.get_maybe_exist_named_child ('work')
 163     if work:
 164         set_if_exists ('title', work.get_work_title ())
 165         set_if_exists ('worknumber', work.get_work_number ())
 166         set_if_exists ('opus', work.get_opus ())
 167     else:
 168         movement_title = tree.get_maybe_exist_named_child ('movement-title')
 169         if movement_title:
 170             set_if_exists ('title', movement_title.get_text ())
 171
 172     identifications = tree.get_named_children ('identification')
 173     for ids in identifications:
 174         set_if_exists ('copyright', ids.get_rights ())
 175         set_if_exists ('composer', ids.get_composer ())
 176         set_if_exists ('arranger', ids.get_arranger ())
 177         set_if_exists ('editor', ids.get_editor ())
 178         set_if_exists ('poet', ids.get_poet ())
 179
 180         set_if_exists ('tagline', ids.get_encoding_software ())
 181         set_if_exists ('encodingsoftware', ids.get_encoding_software ())
 182         set_if_exists ('encodingdate', ids.get_encoding_date ())
 183         set_if_exists ('encoder', ids.get_encoding_person ())
 184         set_if_exists ('encodingdescription', ids.get_encoding_description ())
 185
 186         # Finally, apply the required compatibility modes
 187         # Some applications created wrong MusicXML files, so we need to
 188         # apply some compatibility mode, e.g. ignoring some features/tags
 189         # in those files
 190         software = ids.get_encoding_software_list ()
 191
 192         # Case 1: "Sibelius 5.1" with the "Dolet 3.4 for Sibelius" plugin
 193         #         is missing all beam ends => ignore all beaming information
 194         if "Dolet 3.4 for Sibelius" in software:
 195             conversion_settings.ignore_beaming = True
 196             progress (_ ("Encountered file created by Dolet 3.4 for Sibelius, containing wrong beaming information. All beaming information in the MusicXML file will be ignored"))
 197         # TODO: Check for other unsupported features
 198
 199     return header
 200
 201 class PartGroupInfo:
 202     def __init__ (self):
 203         self.start = {}
 204         self.end = {}
 205     def is_empty (self):
 206         return len (self.start) + len (self.end) == 0
 207     def add_start (self, g):
 208         self.start[getattr (g, 'number', "1")] = g
 209     def add_end (self, g):
 210         self.end[getattr (g, 'number', "1")] = g
 211     def print_ly (self, printer):
 212         error_message (_ ("Unprocessed PartGroupInfo %s encountered") % self)
 213     def ly_expression (self):
 214         error_message (_ ("Unprocessed PartGroupInfo %s encountered") % self)
 215         return ''
 216
 217 def staff_attributes_to_string_tunings (mxl_attr):
 218     details = mxl_attr.get_maybe_exist_named_child ('staff-details')
 219     if not details:
 220         return []
 221     lines = 6
 222     staff_lines = details.get_maybe_exist_named_child ('staff-lines')
 223     if staff_lines:
 224         lines = string.atoi (staff_lines.get_text ())
 225
 226     tunings = [0]*lines
 227     staff_tunings = details.get_named_children ('staff-tuning')
 228     for i in staff_tunings:
 229         p = musicexp.Pitch()
 230         line = 0
 231         try:
 232             line = string.atoi (i.line) - 1
 233         except ValueError:
 234             pass
 235         tunings[line] = p
 236
 237         step = i.get_named_child (u'tuning-step')
 238         step = step.get_text ().strip ()
 239         p.step = musicxml_step_to_lily (step)
 240
 241         octave = i.get_named_child (u'tuning-octave')
 242         octave = octave.get_text ().strip ()
 243         p.octave = int (octave) - 4
 244
 245         alter = i.get_named_child (u'tuning-alter')
 246         if alter:
 247             p.alteration = int (alter.get_text ().strip ())
 248     # lilypond seems to use the opposite ordering than MusicXML...
 249     tunings.reverse ()
 250
 251     return tunings
 252
 253
 254 def staff_attributes_to_lily_staff (mxl_attr):
 255     if not mxl_attr:
 256         return musicexp.Staff ()
 257
 258     (staff_id, attributes) = mxl_attr.items ()[0]
 259
 260     # distinguish by clef:
 261     # percussion (percussion and rhythmic), tab, and everything else
 262     clef_sign = None
 263     clef = attributes.get_maybe_exist_named_child ('clef')
 264     if clef:
 265         sign = clef.get_maybe_exist_named_child ('sign')
 266         if sign:
 267             clef_sign = {"percussion": "percussion", "TAB": "tab"}.get (sign.get_text (), None)
 268
 269     lines = 5
 270     details = attributes.get_named_children ('staff-details')
 271     for d in details:
 272         staff_lines = d.get_maybe_exist_named_child ('staff-lines')
 273         if staff_lines:
 274             lines = string.atoi (staff_lines.get_text ())
 275
 276     staff = None
 277     if clef_sign == "percussion" and lines == 1:
 278         staff = musicexp.RhythmicStaff ()
 279     elif clef_sign == "percussion":
 280         staff = musicexp.DrumStaff ()
 281         # staff.drum_style_table = ???
 282     elif clef_sign == "tab":
 283         staff = musicexp.TabStaff ()
 284         staff.string_tunings = staff_attributes_to_string_tunings (attributes)
 285         # staff.tablature_format = ???
 286     else:
 287         # TODO: Handle case with lines <> 5!
 288         staff = musicexp.Staff ()
 289
 290     return staff
 291
 292
 293 def extract_score_layout (part_list, staffinfo):
 294     layout = musicexp.StaffGroup (None)
 295     if not part_list:
 296         return layout
 297
 298     def read_score_part (el):
 299         if not isinstance (el, musicxml.Score_part):
 300             return
 301         # Depending on the attributes of the first measure, we create different
 302         # types of staves (Staff, RhythmicStaff, DrumStaff, TabStaff, etc.)
 303         staff = staff_attributes_to_lily_staff (staffinfo.get (el.id, None))
 304         if not staff:
 305             return None
 306         staff.id = el.id
 307         partname = el.get_maybe_exist_named_child ('part-name')
 308         # Finale gives unnamed parts the name "MusicXML Part" automatically!
 309         if partname and partname.get_text() != "MusicXML Part":
 310             staff.instrument_name = partname.get_text ()
 311         if el.get_maybe_exist_named_child ('part-abbreviation'):
 312             staff.short_instrument_name = el.get_maybe_exist_named_child ('part-abbreviation').get_text ()
 313         # TODO: Read in the MIDI device / instrument
 314         return staff
 315
 316     def read_score_group (el):
 317         if not isinstance (el, musicxml.Part_group):
 318             return
 319         group = musicexp.StaffGroup ()
 320         if hasattr (el, 'number'):
 321             id = el.number
 322             group.id = id
 323             #currentgroups_dict[id] = group
 324             #currentgroups.append (id)
 325         if el.get_maybe_exist_named_child ('group-name'):
 326             group.instrument_name = el.get_maybe_exist_named_child ('group-name').get_text ()
 327         if el.get_maybe_exist_named_child ('group-abbreviation'):
 328             group.short_instrument_name = el.get_maybe_exist_named_child ('group-abbreviation').get_text ()
 329         if el.get_maybe_exist_named_child ('group-symbol'):
 330             group.symbol = el.get_maybe_exist_named_child ('group-symbol').get_text ()
 331         if el.get_maybe_exist_named_child ('group-barline'):
 332             group.spanbar = el.get_maybe_exist_named_child ('group-barline').get_text ()
 333         return group
 334
 335
 336     parts_groups = part_list.get_all_children ()
 337
 338     # the start/end group tags are not necessarily ordered correctly and groups
 339     # might even overlap, so we can't go through the children sequentially!
 340
 341     # 1) Replace all Score_part objects by their corresponding Staff objects,
 342     #    also collect all group start/stop points into one PartGroupInfo object
 343     staves = []
 344     group_info = PartGroupInfo ()
 345     for el in parts_groups:
 346         if isinstance (el, musicxml.Score_part):
 347             if not group_info.is_empty ():
 348                 staves.append (group_info)
 349                 group_info = PartGroupInfo ()
 350             staff = read_score_part (el)
 351             if staff:
 352                 staves.append (staff)
 353         elif isinstance (el, musicxml.Part_group):
 354             if el.type == "start":
 355                 group_info.add_start (el)
 356             elif el.type == "stop":
 357                 group_info.add_end (el)
 358     if not group_info.is_empty ():
 359         staves.append (group_info)
 360
 361     # 2) Now, detect the groups:
 362     group_starts = []
 363     pos = 0
 364     while pos < len (staves):
 365         el = staves[pos]
 366         if isinstance (el, PartGroupInfo):
 367             prev_start = 0
 368             if len (group_starts) > 0:
 369                 prev_start = group_starts[-1]
 370             elif len (el.end) > 0: # no group to end here
 371                 el.end = {}
 372             if len (el.end) > 0: # closes an existing group
 373                 ends = el.end.keys ()
 374                 prev_started = staves[prev_start].start.keys ()
 375                 grpid = None
 376                 intersection = filter(lambda x:x in ends, prev_started)
 377                 if len (intersection) > 0:
 378                     grpid = intersection[0]
 379                 else:
 380                     # Close the last started group
 381                     grpid = staves[prev_start].start.keys () [0]
 382                     # Find the corresponding closing tag and remove it!
 383                     j = pos + 1
 384                     foundclosing = False
 385                     while j < len (staves) and not foundclosing:
 386                         if isinstance (staves[j], PartGroupInfo) and staves[j].end.has_key (grpid):
 387                             foundclosing = True
 388                             del staves[j].end[grpid]
 389                             if staves[j].is_empty ():
 390                                 del staves[j]
 391                         j += 1
 392                 grpobj = staves[prev_start].start[grpid]
 393                 group = read_score_group (grpobj)
 394                 # remove the id from both the start and end
 395                 if el.end.has_key (grpid):
 396                     del el.end[grpid]
 397                 del staves[prev_start].start[grpid]
 398                 if el.is_empty ():
 399                     del staves[pos]
 400                 # replace the staves with the whole group
 401                 for j in staves[(prev_start + 1):pos]:
 402                     if j.is_group:
 403                         j.stafftype = "InnerStaffGroup"
 404                     group.append_staff (j)
 405                 del staves[(prev_start + 1):pos]
 406                 staves.insert (prev_start + 1, group)
 407                 # reset pos so that we continue at the correct position
 408                 pos = prev_start
 409                 # remove an empty start group
 410                 if staves[prev_start].is_empty ():
 411                     del staves[prev_start]
 412                     group_starts.remove (prev_start)
 413                     pos -= 1
 414             elif len (el.start) > 0: # starts new part groups
 415                 group_starts.append (pos)
 416         pos += 1
 417
 418     if len (staves) == 1:
 419         return staves[0]
 420     for i in staves:
 421         layout.append_staff (i)
 422     return layout
 423
 424
 425
 426 def musicxml_duration_to_lily (mxl_note):
 427     d = musicexp.Duration ()
 428     # if the note has no Type child, then that method spits out a warning and
 429     # returns 0, i.e. a whole note
 430     d.duration_log = mxl_note.get_duration_log ()
 431
 432     d.dots = len (mxl_note.get_typed_children (musicxml.Dot))
 433     # Grace notes by specification have duration 0, so no time modification
 434     # factor is possible. It even messes up the output with *0/1
 435     if not mxl_note.get_maybe_exist_typed_child (musicxml.Grace):
 436         d.factor = mxl_note._duration / d.get_length ()
 437
 438     return d
 439
 440 def rational_to_lily_duration (rational_len):
 441     d = musicexp.Duration ()
 442     d.duration_log = {1: 0, 2: 1, 4:2, 8:3, 16:4, 32:5, 64:6, 128:7, 256:8, 512:9}.get (rational_len.denominator (), -1)
 443     d.factor = Rational (rational_len.numerator ())
 444     if d.duration_log < 0:
 445         error_message (_ ("Encountered rational duration with denominator %s, "
 446                        "unable to convert to lilypond duration") %
 447                        rational_len.denominator ())
 448         # TODO: Test the above error message
 449         return None
 450     else:
 451         return d
 452
 453 def musicxml_partial_to_lily (partial_len):
 454     if partial_len > 0:
 455         p = musicexp.Partial ()
 456         p.partial = rational_to_lily_duration (partial_len)
 457         return p
 458     else:
 459         return Null
 460
 461 # Detect repeats and alternative endings in the chord event list (music_list)
 462 # and convert them to the corresponding musicexp objects, containing nested
 463 # music
 464 def group_repeats (music_list):
 465     repeat_replaced = True
 466     music_start = 0
 467     i = 0
 468     # Walk through the list of expressions, looking for repeat structure
 469     # (repeat start/end, corresponding endings). If we find one, try to find the
 470     # last event of the repeat, replace the whole structure and start over again.
 471     # For nested repeats, as soon as we encounter another starting repeat bar,
 472     # treat that one first, and start over for the outer repeat.
 473     while repeat_replaced and i < 100:
 474         i += 1
 475         repeat_start = -1  # position of repeat start / end
 476         repeat_end = -1 # position of repeat start / end
 477         repeat_times = 0
 478         ending_start = -1 # position of current ending start
 479         endings = [] # list of already finished endings
 480         pos = 0
 481         last = len (music_list) - 1
 482         repeat_replaced = False
 483         final_marker = 0
 484         while pos < len (music_list) and not repeat_replaced:
 485             e = music_list[pos]
 486             repeat_finished = False
 487             if isinstance (e, RepeatMarker):
 488                 if not repeat_times and e.times:
 489                     repeat_times = e.times
 490                 if e.direction == -1:
 491                     if repeat_end >= 0:
 492                         repeat_finished = True
 493                     else:
 494                         repeat_start = pos
 495                         repeat_end = -1
 496                         ending_start = -1
 497                         endings = []
 498                 elif e.direction == 1:
 499                     if repeat_start < 0:
 500                         repeat_start = 0
 501                     if repeat_end < 0:
 502                         repeat_end = pos
 503                     final_marker = pos
 504             elif isinstance (e, EndingMarker):
 505                 if e.direction == -1:
 506                     if repeat_start < 0:
 507                         repeat_start = 0
 508                     if repeat_end < 0:
 509                         repeat_end = pos
 510                     ending_start = pos
 511                 elif e.direction == 1:
 512                     if ending_start < 0:
 513                         ending_start = 0
 514                     endings.append ([ending_start, pos])
 515                     ending_start = -1
 516                     final_marker = pos
 517             elif not isinstance (e, musicexp.BarLine):
 518                 # As soon as we encounter an element when repeat start and end
 519                 # is set and we are not inside an alternative ending,
 520                 # this whole repeat structure is finished => replace it
 521                 if repeat_start >= 0 and repeat_end > 0 and ending_start < 0:
 522                     repeat_finished = True
 523
 524             # Finish off all repeats without explicit ending bar (e.g. when
 525             # we convert only one page of a multi-page score with repeats)
 526             if pos == last and repeat_start >= 0:
 527                 repeat_finished = True
 528                 final_marker = pos
 529                 if repeat_end < 0:
 530                     repeat_end = pos
 531                 if ending_start >= 0:
 532                     endings.append ([ending_start, pos])
 533                     ending_start = -1
 534
 535             if repeat_finished:
 536                 # We found the whole structure replace it!
 537                 r = musicexp.RepeatedMusic ()
 538                 if repeat_times <= 0:
 539                     repeat_times = 2
 540                 r.repeat_count = repeat_times
 541                 # don't erase the first element for "implicit" repeats (i.e. no
 542                 # starting repeat bars at the very beginning)
 543                 start = repeat_start+1
 544                 if repeat_start == music_start:
 545                     start = music_start
 546                 r.set_music (music_list[start:repeat_end])
 547                 for (start, end) in endings:
 548                     s = musicexp.SequentialMusic ()
 549                     s.elements = music_list[start+1:end]
 550                     r.add_ending (s)
 551                 del music_list[repeat_start:final_marker+1]
 552                 music_list.insert (repeat_start, r)
 553                 repeat_replaced = True
 554             pos += 1
 555         # TODO: Implement repeats until the end without explicit ending bar
 556     return music_list
 557
 558
 559
 560 def group_tuplets (music_list, events):
 561
 562
 563     """Collect Musics from
 564     MUSIC_LIST demarcated by EVENTS_LIST in TimeScaledMusic objects.
 565     """
 566
 567
 568     indices = []
 569
 570     j = 0
 571     for (ev_chord, tuplet_elt, fraction) in events:
 572         while (j < len (music_list)):
 573             if music_list[j] == ev_chord:
 574                 break
 575             j += 1
 576         if tuplet_elt.type == 'start':
 577             indices.append ((j, None, fraction))
 578         elif tuplet_elt.type == 'stop':
 579             indices[-1] = (indices[-1][0], j, indices[-1][2])
 580
 581     new_list = []
 582     last = 0
 583     for (i1, i2, frac) in indices:
 584         if i1 >= i2:
 585             continue
 586
 587         new_list.extend (music_list[last:i1])
 588         seq = musicexp.SequentialMusic ()
 589         last = i2 + 1
 590         seq.elements = music_list[i1:last]
 591
 592         tsm = musicexp.TimeScaledMusic ()
 593         tsm.element = seq
 594
 595         tsm.numerator = frac[0]
 596         tsm.denominator  = frac[1]
 597
 598         new_list.append (tsm)
 599
 600     new_list.extend (music_list[last:])
 601     return new_list
 602
 603
 604 def musicxml_clef_to_lily (attributes):
 605     change = musicexp.ClefChange ()
 606     (change.type, change.position, change.octave) = attributes.get_clef_information ()
 607     return change
 608
 609 def musicxml_time_to_lily (attributes):
 610     (beats, type) = attributes.get_time_signature ()
 611
 612     change = musicexp.TimeSignatureChange()
 613     change.fraction = (beats, type)
 614
 615     return change
 616
 617 def musicxml_key_to_lily (attributes):
 618     start_pitch  = musicexp.Pitch ()
 619     (fifths, mode) = attributes.get_key_signature ()
 620     try:
 621         (n,a) = {
 622             'major' : (0,0),
 623             'minor' : (5,0),
 624             }[mode]
 625         start_pitch.step = n
 626         start_pitch.alteration = a
 627     except  KeyError:
 628         error_message (_ ("unknown mode %s, expecting 'major' or 'minor'") % mode)
 629
 630     fifth = musicexp.Pitch()
 631     fifth.step = 4
 632     if fifths < 0:
 633         fifths *= -1
 634         fifth.step *= -1
 635         fifth.normalize ()
 636
 637     for x in range (fifths):
 638         start_pitch = start_pitch.transposed (fifth)
 639
 640     start_pitch.octave = 0
 641
 642     change = musicexp.KeySignatureChange()
 643     change.mode = mode
 644     change.tonic = start_pitch
 645     return change
 646
 647 def musicxml_attributes_to_lily (attrs):
 648     elts = []
 649     attr_dispatch =  {
 650         'clef': musicxml_clef_to_lily,
 651         'time': musicxml_time_to_lily,
 652         'key': musicxml_key_to_lily
 653     }
 654     for (k, func) in attr_dispatch.items ():
 655         children = attrs.get_named_children (k)
 656         if children:
 657             elts.append (func (attrs))
 658
 659     return elts
 660
 661 class Marker (musicexp.Music):
 662     def __init__ (self):
 663         self.direction = 0
 664         self.event = None
 665     def print_ly (self, printer):
 666         ly.stderr_write (_ ("Encountered unprocessed marker %s\n") % self)
 667         pass
 668     def ly_expression (self):
 669         return ""
 670 class RepeatMarker (Marker):
 671     def __init__ (self):
 672         Marker.__init__ (self)
 673         self.times = 0
 674 class EndingMarker (Marker):
 675     pass
 676
 677 # Convert the <barline> element to musicxml.BarLine (for non-standard barlines)
 678 # and to RepeatMarker and EndingMarker objects for repeat and
 679 # alternatives start/stops
 680 def musicxml_barline_to_lily (barline):
 681     # retval contains all possible markers in the order:
 682     # 0..bw_ending, 1..bw_repeat, 2..barline, 3..fw_repeat, 4..fw_ending
 683     retval = {}
 684     bartype_element = barline.get_maybe_exist_named_child ("bar-style")
 685     repeat_element = barline.get_maybe_exist_named_child ("repeat")
 686     ending_element = barline.get_maybe_exist_named_child ("ending")
 687
 688     bartype = None
 689     if bartype_element:
 690         bartype = bartype_element.get_text ()
 691
 692     if repeat_element and hasattr (repeat_element, 'direction'):
 693         repeat = RepeatMarker ()
 694         repeat.direction = {"forward": -1, "backward": 1}.get (repeat_element.direction, 0)
 695
 696         if ( (repeat_element.direction == "forward" and bartype == "heavy-light") or
 697              (repeat_element.direction == "backward" and bartype == "light-heavy") ):
 698             bartype = None
 699         if hasattr (repeat_element, 'times'):
 700             try:
 701                 repeat.times = int (repeat_element.times)
 702             except ValueError:
 703                 repeat.times = 2
 704         repeat.event = barline
 705         if repeat.direction == -1:
 706             retval[3] = repeat
 707         else:
 708             retval[1] = repeat
 709
 710     if ending_element and hasattr (ending_element, 'type'):
 711         ending = EndingMarker ()
 712         ending.direction = {"start": -1, "stop": 1, "discontinue": 1}.get (ending_element.type, 0)
 713         ending.event = barline
 714         if ending.direction == -1:
 715             retval[4] = ending
 716         else:
 717             retval[0] = ending
 718
 719     if bartype:
 720         b = musicexp.BarLine ()
 721         b.type = bartype
 722         retval[2] = b
 723
 724     return retval.values ()
 725
 726 spanner_event_dict = {
 727     'beam' : musicexp.BeamEvent,
 728     'dashes' : musicexp.TextSpannerEvent,
 729     'bracket' : musicexp.BracketSpannerEvent,
 730     'glissando' : musicexp.GlissandoEvent,
 731     'octave-shift' : musicexp.OctaveShiftEvent,
 732     'pedal' : musicexp.PedalEvent,
 733     'slide' : musicexp.GlissandoEvent,
 734     'slur' : musicexp.SlurEvent,
 735     'wavy-line' : musicexp.TrillSpanEvent,
 736     'wedge' : musicexp.HairpinEvent
 737 }
 738 spanner_type_dict = {
 739     'start': -1,
 740     'begin': -1,
 741     'crescendo': -1,
 742     'decreschendo': -1,
 743     'diminuendo': -1,
 744     'continue': 0,
 745     'change': 0,
 746     'up': -1,
 747     'down': -1,
 748     'stop': 1,
 749     'end' : 1
 750 }
 751
 752 def musicxml_spanner_to_lily_event (mxl_event):
 753     ev = None
 754
 755     name = mxl_event.get_name()
 756     func = spanner_event_dict.get (name)
 757     if func:
 758         ev = func()
 759     else:
 760         error_message (_ ('unknown span event %s') % mxl_event)
 761
 762
 763     type = mxl_event.get_type ()
 764     span_direction = spanner_type_dict.get (type)
 765     # really check for None, because some types will be translated to 0, which
 766     # would otherwise also lead to the unknown span warning
 767     if span_direction != None:
 768         ev.span_direction = span_direction
 769     else:
 770         error_message (_ ('unknown span type %s for %s') % (type, name))
 771
 772     ev.set_span_type (type)
 773     ev.line_type = getattr (mxl_event, 'line-type', 'solid')
 774
 775     # assign the size, which is used for octave-shift, etc.
 776     ev.size = mxl_event.get_size ()
 777
 778     return ev
 779
 780 def musicxml_direction_to_indicator (direction):
 781     return { "above": 1, "upright": 1, "up": 1, "below": -1, "downright": -1, "down": -1, "inverted": -1 }.get (direction, 0)
 782
 783 def musicxml_fermata_to_lily_event (mxl_event):
 784     ev = musicexp.ArticulationEvent ()
 785     txt = mxl_event.get_text ()
 786     # The contents of the element defined the shape, possible are normal, angled and square
 787     ev.type = { "angled": "shortfermata", "square": "longfermata" }.get (txt, "fermata")
 788     if hasattr (mxl_event, 'type'):
 789       dir = musicxml_direction_to_indicator (mxl_event.type)
 790       if dir and options.convert_directions:
 791         ev.force_direction = dir
 792     return ev
 793
 794 def musicxml_arpeggiate_to_lily_event (mxl_event):
 795     ev = musicexp.ArpeggioEvent ()
 796     ev.direction = musicxml_direction_to_indicator (getattr (mxl_event, 'direction', None))
 797     return ev
 798
 799 def musicxml_nonarpeggiate_to_lily_event (mxl_event):
 800     ev = musicexp.ArpeggioEvent ()
 801     ev.non_arpeggiate = True
 802     ev.direction = musicxml_direction_to_indicator (getattr (mxl_event, 'direction', None))
 803     return ev
 804
 805 def musicxml_tremolo_to_lily_event (mxl_event):
 806     ev = musicexp.TremoloEvent ()
 807     txt = mxl_event.get_text ()
 808     if txt:
 809       ev.bars = txt
 810     else:
 811       ev.bars = "3"
 812     return ev
 813
 814 def musicxml_falloff_to_lily_event (mxl_event):
 815     ev = musicexp.BendEvent ()
 816     ev.alter = -4
 817     return ev
 818
 819 def musicxml_doit_to_lily_event (mxl_event):
 820     ev = musicexp.BendEvent ()
 821     ev.alter = 4
 822     return ev
 823
 824 def musicxml_bend_to_lily_event (mxl_event):
 825     ev = musicexp.BendEvent ()
 826     ev.alter = mxl_event.bend_alter ()
 827     return ev
 828
 829 def musicxml_caesura_to_lily_event (mxl_event):
 830     ev = musicexp.MarkupEvent ()
 831     # FIXME: default to straight or curved caesura?
 832     ev.contents = "\\musicglyph #\"scripts.caesura.straight\""
 833     ev.force_direction = 1
 834     return ev
 835
 836 def musicxml_fingering_event (mxl_event):
 837     ev = musicexp.ShortArticulationEvent ()
 838     ev.type = mxl_event.get_text ()
 839     return ev
 840
 841 def musicxml_snappizzicato_event (mxl_event):
 842     needed_additional_definitions.append ("snappizzicato")
 843     ev = musicexp.MarkupEvent ()
 844     ev.contents = "\\snappizzicato"
 845     return ev
 846
 847 def musicxml_string_event (mxl_event):
 848     ev = musicexp.NoDirectionArticulationEvent ()
 849     ev.type = mxl_event.get_text ()
 850     return ev
 851
 852 def musicxml_accidental_mark (mxl_event):
 853     ev = musicexp.MarkupEvent ()
 854     contents = { "sharp": "\\sharp",
 855       "natural": "\\natural",
 856       "flat": "\\flat",
 857       "double-sharp": "\\doublesharp",
 858       "sharp-sharp": "\\sharp\\sharp",
 859       "flat-flat": "\\flat\\flat",
 860       "flat-flat": "\\doubleflat",
 861       "natural-sharp": "\\natural\\sharp",
 862       "natural-flat": "\\natural\\flat",
 863       "quarter-flat": "\\semiflat",
 864       "quarter-sharp": "\\semisharp",
 865       "three-quarters-flat": "\\sesquiflat",
 866       "three-quarters-sharp": "\\sesquisharp",
 867     }.get (mxl_event.get_text ())
 868     if contents:
 869         ev.contents = contents
 870         return ev
 871     else:
 872         return None
 873
 874 # translate articulations, ornaments and other notations into ArticulationEvents
 875 # possible values:
 876 #   -) string  (ArticulationEvent with that name)
 877 #   -) function (function(mxl_event) needs to return a full ArticulationEvent-derived object
 878 #   -) (class, name)  (like string, only that a different class than ArticulationEvent is used)
 879 # TODO: Some translations are missing!
 880 articulations_dict = {
 881     "accent": (musicexp.ShortArticulationEvent, ">"), # or "accent"
 882     "accidental-mark": musicxml_accidental_mark,
 883     "bend": musicxml_bend_to_lily_event,
 884     "breath-mark": (musicexp.NoDirectionArticulationEvent, "breathe"),
 885     "caesura": musicxml_caesura_to_lily_event,
 886     #"delayed-turn": "?",
 887     "detached-legato": (musicexp.ShortArticulationEvent, "_"), # or "portato"
 888     "doit": musicxml_doit_to_lily_event,
 889     #"double-tongue": "",
 890     "down-bow": "downbow",
 891     "falloff": musicxml_falloff_to_lily_event,
 892     "fingering": musicxml_fingering_event,
 893     #"fingernails": "",
 894     #"fret": "",
 895     #"hammer-on": "",
 896     "harmonic": "flageolet",
 897     #"heel": "",
 898     "inverted-mordent": "prall",
 899     "inverted-turn": "reverseturn",
 900     "mordent": "mordent",
 901     "open-string": "open",
 902     #"plop": "",
 903     #"pluck": "",
 904     #"pull-off": "",
 905     #"schleifer": "?",
 906     #"scoop": "",
 907     #"shake": "?",
 908     "snap-pizzicato": musicxml_snappizzicato_event,
 909     #"spiccato": "",
 910     "staccatissimo": (musicexp.ShortArticulationEvent, "|"), # or "staccatissimo"
 911     "staccato": (musicexp.ShortArticulationEvent, "."), # or "staccato"
 912     "stopped": (musicexp.ShortArticulationEvent, "+"), # or "stopped"
 913     #"stress": "",
 914     "string": musicxml_string_event,
 915     "strong-accent": (musicexp.ShortArticulationEvent, "^"), # or "marcato"
 916     #"tap": "",
 917     "tenuto": (musicexp.ShortArticulationEvent, "-"), # or "tenuto"
 918     "thumb-position": "thumb",
 919     #"toe": "",
 920     "turn": "turn",
 921     "tremolo": musicxml_tremolo_to_lily_event,
 922     "trill-mark": "trill",
 923     #"triple-tongue": "",
 924     #"unstress": ""
 925     "up-bow": "upbow",
 926     #"wavy-line": "?",
 927 }
 928 articulation_spanners = [ "wavy-line" ]
 929
 930 def musicxml_articulation_to_lily_event (mxl_event):
 931     # wavy-line elements are treated as trill spanners, not as articulation ornaments
 932     if mxl_event.get_name () in articulation_spanners:
 933         return musicxml_spanner_to_lily_event (mxl_event)
 934
 935     tmp_tp = articulations_dict.get (mxl_event.get_name ())
 936     if not tmp_tp:
 937         return
 938
 939     if isinstance (tmp_tp, str):
 940         ev = musicexp.ArticulationEvent ()
 941         ev.type = tmp_tp
 942     elif isinstance (tmp_tp, tuple):
 943         ev = tmp_tp[0] ()
 944         ev.type = tmp_tp[1]
 945     else:
 946         ev = tmp_tp (mxl_event)
 947
 948     # Some articulations use the type attribute, other the placement...
 949     dir = None
 950     if hasattr (mxl_event, 'type') and options.convert_directions:
 951         dir = musicxml_direction_to_indicator (mxl_event.type)
 952     if hasattr (mxl_event, 'placement') and options.convert_directions:
 953         dir = musicxml_direction_to_indicator (mxl_event.placement)
 954     if dir:
 955         ev.force_direction = dir
 956     return ev
 957
 958
 959
 960 def musicxml_dynamics_to_lily_event (dynentry):
 961     dynamics_available = (
 962         "ppppp", "pppp", "ppp", "pp", "p", "mp", "mf",
 963         "f", "ff", "fff", "ffff", "fp", "sf", "sff", "sp", "spp", "sfz", "rfz" )
 964     dynamicsname = dynentry.get_name ()
 965     if dynamicsname == "other-dynamics":
 966         dynamicsname = dynentry.get_text ()
 967     if not dynamicsname or dynamicsname=="#text":
 968         return
 969
 970     if not dynamicsname in dynamics_available:
 971         # Get rid of - in tag names (illegal in ly tags!)
 972         dynamicstext = dynamicsname
 973         dynamicsname = string.replace (dynamicsname, "-", "")
 974         additional_definitions[dynamicsname] = dynamicsname + \
 975               " = #(make-dynamic-script \"" + dynamicstext + "\")"
 976         needed_additional_definitions.append (dynamicsname)
 977     event = musicexp.DynamicsEvent ()
 978     event.type = dynamicsname
 979     return event
 980
 981 # Convert single-color two-byte strings to numbers 0.0 - 1.0
 982 def hexcolorval_to_nr (hex_val):
 983     try:
 984         v = int (hex_val, 16)
 985         if v == 255:
 986             v = 256
 987         return v / 256.
 988     except ValueError:
 989         return 0.
 990
 991 def hex_to_color (hex_val):
 992     res = re.match (r'#([0-9a-f][0-9a-f]|)([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])$', hex_val, re.IGNORECASE)
 993     if res:
 994         return map (lambda x: hexcolorval_to_nr (x), res.group (2,3,4))
 995     else:
 996         return None
 997
 998 def musicxml_words_to_lily_event (words):
 999     event = musicexp.TextEvent ()
1000     text = words.get_text ()
1001     text = re.sub ('^ *\n? *', '', text)
1002     text = re.sub (' *\n? *$', '', text)
1003     event.text = text
1004
1005     if hasattr (words, 'default-y') and options.convert_directions:
1006         offset = getattr (words, 'default-y')
1007         try:
1008             off = string.atoi (offset)
1009             if off > 0:
1010                 event.force_direction = 1
1011             else:
1012                 event.force_direction = -1
1013         except ValueError:
1014             event.force_direction = 0
1015
1016     if hasattr (words, 'font-weight'):
1017         font_weight = { "normal": '', "bold": '\\bold' }.get (getattr (words, 'font-weight'), '')
1018         if font_weight:
1019             event.markup += font_weight
1020
1021     if hasattr (words, 'font-size'):
1022         size = getattr (words, 'font-size')
1023         font_size = {
1024             "xx-small": '\\teeny',
1025             "x-small": '\\tiny',
1026             "small": '\\small',
1027             "medium": '',
1028             "large": '\\large',
1029             "x-large": '\\huge',
1030             "xx-large": '\\bigger\\huge'
1031         }.get (size, '')
1032         if font_size:
1033             event.markup += font_size
1034
1035     if hasattr (words, 'color'):
1036         color = getattr (words, 'color')
1037         rgb = hex_to_color (color)
1038         if rgb:
1039             event.markup += "\\with-color #(rgb-color %s %s %s)" % (rgb[0], rgb[1], rgb[2])
1040
1041     if hasattr (words, 'font-style'):
1042         font_style = { "italic": '\\italic' }.get (getattr (words, 'font-style'), '')
1043         if font_style:
1044             event.markup += font_style
1045
1046     # TODO: How should I best convert the font-family attribute?
1047
1048     # TODO: How can I represent the underline, overline and line-through
1049     #       attributes in Lilypond? Values of these attributes indicate
1050     #       the number of lines
1051
1052     return event
1053
1054
1055 # convert accordion-registration to lilypond.
1056 # Since lilypond does not have any built-in commands, we need to create
1057 # the markup commands manually and define our own variables.
1058 # Idea was taken from: http://lsr.dsi.unimi.it/LSR/Item?id=194
1059 def musicxml_accordion_to_markup (mxl_event):
1060     commandname = "accReg"
1061     command = ""
1062
1063     high = mxl_event.get_maybe_exist_named_child ('accordion-high')
1064     if high:
1065         commandname += "H"
1066         command += """\\combine
1067           \\raise #2.5 \\musicglyph #\"accordion.accDot\"
1068           """
1069     middle = mxl_event.get_maybe_exist_named_child ('accordion-middle')
1070     if middle:
1071         # By default, use one dot (when no or invalid content is given). The
1072         # MusicXML spec is quiet about this case...
1073         txt = 1
1074         try:
1075           txt = string.atoi (middle.get_text ())
1076         except ValueError:
1077             pass
1078         if txt == 3:
1079             commandname += "MMM"
1080             command += """\\combine
1081           \\raise #1.5 \\musicglyph #\"accordion.accDot\"
1082           \\combine
1083           \\raise #1.5 \\translate #(cons 1 0) \\musicglyph #\"accordion.accDot\"
1084           \\combine
1085           \\raise #1.5 \\translate #(cons -1 0) \\musicglyph #\"accordion.accDot\"
1086           """
1087         elif txt == 2:
1088             commandname += "MM"
1089             command += """\\combine
1090           \\raise #1.5 \\translate #(cons 0.5 0) \\musicglyph #\"accordion.accDot\"
1091           \\combine
1092           \\raise #1.5 \\translate #(cons -0.5 0) \\musicglyph #\"accordion.accDot\"
1093           """
1094         elif not txt <= 0:
1095             commandname += "M"
1096             command += """\\combine
1097           \\raise #1.5 \\musicglyph #\"accordion.accDot\"
1098           """
1099     low = mxl_event.get_maybe_exist_named_child ('accordion-low')
1100     if low:
1101         commandname += "L"
1102         command += """\\combine
1103           \\raise #0.5 \musicglyph #\"accordion.accDot\"
1104           """
1105
1106     command += "\musicglyph #\"accordion.accDiscant\""
1107     command = "\\markup { \\normalsize %s }" % command
1108     # Define the newly built command \accReg[H][MMM][L]
1109     additional_definitions[commandname] = "%s = %s" % (commandname, command)
1110     needed_additional_definitions.append (commandname)
1111     return "\\%s" % commandname
1112
1113 def musicxml_accordion_to_ly (mxl_event):
1114     txt = musicxml_accordion_to_markup (mxl_event)
1115     if txt:
1116         ev = musicexp.MarkEvent (txt)
1117         return ev
1118     return
1119
1120
1121 def musicxml_rehearsal_to_ly_mark (mxl_event):
1122     text = mxl_event.get_text ()
1123     if not text:
1124         return
1125     # default is boxed rehearsal marks!
1126     encl = "box"
1127     if hasattr (mxl_event, 'enclosure'):
1128         encl = {"none": None, "square": "box", "circle": "circle" }.get (mxl_event.enclosure, None)
1129     if encl:
1130         text = "\\%s { %s }" % (encl, text)
1131     ev = musicexp.MarkEvent ("\\markup { %s }" % text)
1132     return ev
1133
1134 # translate directions into Events, possible values:
1135 #   -) string  (MarkEvent with that command)
1136 #   -) function (function(mxl_event) needs to return a full Event-derived object
1137 #   -) (class, name)  (like string, only that a different class than MarkEvent is used)
1138 directions_dict = {
1139     'accordion-registration' : musicxml_accordion_to_ly,
1140     'coda' : (musicexp.MusicGlyphMarkEvent, "coda"),
1141 #     'damp' : ???
1142 #     'damp-all' : ???
1143 #     'eyeglasses': ??????
1144 #     'harp-pedals' :
1145 #     'image' :
1146 #     'metronome' :
1147     'rehearsal' : musicxml_rehearsal_to_ly_mark,
1148 #     'scordatura' :
1149     'segno' : (musicexp.MusicGlyphMarkEvent, "segno"),
1150     'words' : musicxml_words_to_lily_event,
1151 }
1152 directions_spanners = [ 'octave-shift', 'pedal', 'wedge', 'dashes', 'bracket' ]
1153
1154 def musicxml_direction_to_lily (n):
1155     # TODO: Handle the <staff> element!
1156     res = []
1157     # placement applies to all children!
1158     dir = None
1159     if hasattr (n, 'placement') and options.convert_directions:
1160         dir = musicxml_direction_to_indicator (n.placement)
1161     dirtype_children = []
1162     # TODO: The direction-type is used for grouping (e.g. dynamics with text),
1163     #       so we can't simply flatten them out!
1164     for dt in n.get_typed_children (musicxml.DirType):
1165         dirtype_children += dt.get_all_children ()
1166
1167     for entry in dirtype_children:
1168         # backets, dashes, octave shifts. pedal marks, hairpins etc. are spanners:
1169         if entry.get_name() in directions_spanners:
1170             event = musicxml_spanner_to_lily_event (entry)
1171             if event:
1172                 res.append (event)
1173             continue
1174
1175         # now treat all the "simple" ones, that can be translated using the dict
1176         ev = None
1177         tmp_tp = directions_dict.get (entry.get_name (), None)
1178         if isinstance (tmp_tp, str): # string means MarkEvent
1179             ev = musicexp.MarkEvent (tmp_tp)
1180         elif isinstance (tmp_tp, tuple): # tuple means (EventClass, "text")
1181             ev = tmp_tp[0] (tmp_tp[1])
1182         elif tmp_tp:
1183             ev = tmp_tp (entry)
1184         if ev:
1185             # TODO: set the correct direction! Unfortunately, \mark in ly does
1186             #       not seem to support directions!
1187             res.append (ev)
1188             continue
1189
1190         if entry.get_name () == "dynamics":
1191             for dynentry in entry.get_all_children ():
1192                 ev = musicxml_dynamics_to_lily_event (dynentry)
1193                 if ev:
1194                     res.append (ev)
1195
1196     return res
1197
1198 def musicxml_frame_to_lily_event (frame):
1199     ev = musicexp.FretEvent ()
1200     ev.strings = frame.get_strings ()
1201     ev.frets = frame.get_frets ()
1202     #offset = frame.get_first_fret () - 1
1203     barre = []
1204     for fn in frame.get_named_children ('frame-note'):
1205         fret = fn.get_fret ()
1206         if fret <= 0:
1207             fret = "o"
1208         el = [ fn.get_string (), fret ]
1209         fingering = fn.get_fingering ()
1210         if fingering >= 0:
1211             el.append (fingering)
1212         ev.elements.append (el)
1213         b = fn.get_barre ()
1214         if b == 'start':
1215             barre[0] = el[0] # start string
1216             barre[2] = el[1] # fret
1217         elif b == 'stop':
1218             barre[1] = el[0] # end string
1219     if barre:
1220         ev.barre = barre
1221     return ev
1222
1223 def musicxml_harmony_to_lily (n):
1224     res = []
1225     for f in n.get_named_children ('frame'):
1226         ev = musicxml_frame_to_lily_event (f)
1227         if ev:
1228             res.append (ev)
1229
1230     return res
1231
1232 instrument_drumtype_dict = {
1233     'Acoustic Snare Drum': 'acousticsnare',
1234     'Side Stick': 'sidestick',
1235     'Open Triangle': 'opentriangle',
1236     'Mute Triangle': 'mutetriangle',
1237     'Tambourine': 'tambourine',
1238     'Bass Drum': 'bassdrum',
1239 }
1240
1241 def musicxml_note_to_lily_main_event (n):
1242     pitch  = None
1243     duration = None
1244     event = None
1245
1246     mxl_pitch = n.get_maybe_exist_typed_child (musicxml.Pitch)
1247     if mxl_pitch:
1248         pitch = musicxml_pitch_to_lily (mxl_pitch)
1249         event = musicexp.NoteEvent ()
1250         event.pitch = pitch
1251
1252         acc = n.get_maybe_exist_named_child ('accidental')
1253         if acc:
1254             # let's not force accs everywhere.
1255             event.cautionary = acc.editorial
1256
1257     elif n.get_maybe_exist_typed_child (musicxml.Unpitched):
1258         # Unpitched elements have display-step and can also have
1259         # display-octave.
1260         unpitched = n.get_maybe_exist_typed_child (musicxml.Unpitched)
1261         event = musicexp.NoteEvent ()
1262         event.pitch = musicxml_unpitched_to_lily (unpitched)
1263
1264     elif n.get_maybe_exist_typed_child (musicxml.Rest):
1265         # rests can have display-octave and display-step, which are
1266         # treated like an ordinary note pitch
1267         rest = n.get_maybe_exist_typed_child (musicxml.Rest)
1268         event = musicexp.RestEvent ()
1269         pitch = musicxml_restdisplay_to_lily (rest)
1270         event.pitch = pitch
1271
1272     elif n.instrument_name:
1273         event = musicexp.NoteEvent ()
1274         drum_type = instrument_drumtype_dict.get (n.instrument_name)
1275         if drum_type:
1276             event.drum_type = drum_type
1277         else:
1278             n.message (_ ("drum %s type unknown, please add to instrument_drumtype_dict") % n.instrument_name)
1279             event.drum_type = 'acousticsnare'
1280
1281     else:
1282         n.message (_ ("cannot find suitable event"))
1283
1284     if event:
1285         event.duration = musicxml_duration_to_lily (n)
1286
1287     return event
1288
1289
1290 ## TODO
1291 class NegativeSkip:
1292     def __init__ (self, here, dest):
1293         self.here = here
1294         self.dest = dest
1295
1296 class LilyPondVoiceBuilder:
1297     def __init__ (self):
1298         self.elements = []
1299         self.pending_dynamics = []
1300         self.end_moment = Rational (0)
1301         self.begin_moment = Rational (0)
1302         self.pending_multibar = Rational (0)
1303         self.ignore_skips = False
1304
1305     def _insert_multibar (self):
1306         r = musicexp.MultiMeasureRest ()
1307         r.duration = musicexp.Duration()
1308         r.duration.duration_log = 0
1309         r.duration.factor = self.pending_multibar
1310         self.elements.append (r)
1311         self.begin_moment = self.end_moment
1312         self.end_moment = self.begin_moment + self.pending_multibar
1313         self.pending_multibar = Rational (0)
1314
1315     def add_multibar_rest (self, duration):
1316         self.pending_multibar += duration
1317
1318     def set_duration (self, duration):
1319         self.end_moment = self.begin_moment + duration
1320     def current_duration (self):
1321         return self.end_moment - self.begin_moment
1322
1323     def add_music (self, music, duration):
1324         assert isinstance (music, musicexp.Music)
1325         if self.pending_multibar > Rational (0):
1326             self._insert_multibar ()
1327
1328         self.elements.append (music)
1329         self.begin_moment = self.end_moment
1330         self.set_duration (duration)
1331
1332         # Insert all pending dynamics right after the note/rest:
1333         if isinstance (music, musicexp.ChordEvent) and self.pending_dynamics:
1334             for d in self.pending_dynamics:
1335                 music.append (d)
1336             self.pending_dynamics = []
1337
1338     # Insert some music command that does not affect the position in the measure
1339     def add_command (self, command):
1340         assert isinstance (command, musicexp.Music)
1341         if self.pending_multibar > Rational (0):
1342             self._insert_multibar ()
1343         self.elements.append (command)
1344     def add_barline (self, barline):
1345         # TODO: Implement merging of default barline and custom bar line
1346         self.add_music (barline, Rational (0))
1347     def add_partial (self, command):
1348         self.ignore_skips = True
1349         self.add_command (command)
1350
1351     def add_dynamics (self, dynamic):
1352         # store the dynamic item(s) until we encounter the next note/rest:
1353         self.pending_dynamics.append (dynamic)
1354
1355     def add_bar_check (self, number):
1356         b = musicexp.BarLine ()
1357         b.bar_number = number
1358         self.add_barline (b)
1359
1360     def jumpto (self, moment):
1361         current_end = self.end_moment + self.pending_multibar
1362         diff = moment - current_end
1363
1364         if diff < Rational (0):
1365             error_message (_ ('Negative skip %s') % diff)
1366             diff = Rational (0)
1367
1368         if diff > Rational (0) and not (self.ignore_skips and moment == 0):
1369             skip = musicexp.SkipEvent()
1370             duration_factor = 1
1371             duration_log = {1: 0, 2: 1, 4:2, 8:3, 16:4, 32:5, 64:6, 128:7, 256:8, 512:9}.get (diff.denominator (), -1)
1372             duration_dots = 0
1373             if duration_log > 0: # denominator is a power of 2...
1374                 if diff.numerator () == 3:
1375                     duration_log -= 1
1376                     duration_dots = 1
1377                 else:
1378                     duration_factor = Rational (diff.numerator ())
1379             else:
1380                 duration_log = 0
1381                 duration_factor = diff
1382             skip.duration.duration_log = duration_log
1383             skip.duration.factor = duration_factor
1384             skip.duration.dots = duration_dots
1385
1386             evc = musicexp.ChordEvent ()
1387             evc.elements.append (skip)
1388             self.add_music (evc, diff)
1389
1390         if diff > Rational (0) and moment == 0:
1391             self.ignore_skips = False
1392
1393     def last_event_chord (self, starting_at):
1394
1395         value = None
1396
1397         # if the position matches, find the last ChordEvent, do not cross a bar line!
1398         at = len( self.elements ) - 1
1399         while (at >= 0 and
1400                not isinstance (self.elements[at], musicexp.ChordEvent) and
1401                not isinstance (self.elements[at], musicexp.BarLine)):
1402             at -= 1
1403
1404         if (self.elements
1405             and at >= 0
1406             and isinstance (self.elements[at], musicexp.ChordEvent)
1407             and self.begin_moment == starting_at):
1408             value = self.elements[at]
1409         else:
1410             self.jumpto (starting_at)
1411             value = None
1412         return value
1413
1414     def correct_negative_skip (self, goto):
1415         self.end_moment = goto
1416         self.begin_moment = goto
1417         evc = musicexp.ChordEvent ()
1418         self.elements.append (evc)
1419
1420
1421 class VoiceData:
1422     def __init__ (self):
1423         self.voicedata = None
1424         self.ly_voice = None
1425         self.lyrics_dict = {}
1426         self.lyrics_order = []
1427
1428 def musicxml_step_to_lily (step):
1429     if step:
1430         return (ord (step) - ord ('A') + 7 - 2) % 7
1431     else:
1432         return None
1433
1434 def musicxml_voice_to_lily_voice (voice):
1435     tuplet_events = []
1436     modes_found = {}
1437     lyrics = {}
1438     return_value = VoiceData ()
1439     return_value.voicedata = voice
1440
1441     # First pitch needed for relative mode (if selected in command-line options)
1442     first_pitch = None
1443
1444     # Needed for melismata detection (ignore lyrics on those notes!):
1445     inside_slur = False
1446     is_tied = False
1447     is_chord = False
1448     ignore_lyrics = False
1449
1450     current_staff = None
1451
1452     # Make sure that the keys in the dict don't get reordered, since
1453     # we need the correct ordering of the lyrics stanzas! By default,
1454     # a dict will reorder its keys
1455     return_value.lyrics_order = voice.get_lyrics_numbers ()
1456     for k in return_value.lyrics_order:
1457         lyrics[k] = []
1458
1459     voice_builder = LilyPondVoiceBuilder()
1460
1461     for n in voice._elements:
1462         if n.get_name () == 'forward':
1463             continue
1464         staff = n.get_maybe_exist_named_child ('staff')
1465         if staff:
1466             staff = staff.get_text ()
1467             if current_staff and staff <> current_staff and not n.get_maybe_exist_named_child ('chord'):
1468                 voice_builder.add_command (musicexp.StaffChange (staff))
1469             current_staff = staff
1470
1471         if isinstance (n, musicxml.Partial) and n.partial > 0:
1472             a = musicxml_partial_to_lily (n.partial)
1473             if a:
1474                 voice_builder.add_partial (a)
1475             continue
1476
1477         if isinstance (n, musicxml.Direction):
1478             for a in musicxml_direction_to_lily (n):
1479                 if a.wait_for_note ():
1480                     voice_builder.add_dynamics (a)
1481                 else:
1482                     voice_builder.add_command (a)
1483             continue
1484
1485         if isinstance (n, musicxml.Harmony):
1486             for a in musicxml_harmony_to_lily (n):
1487                 if a.wait_for_note ():
1488                     voice_builder.add_dynamics (a)
1489                 else:
1490                     voice_builder.add_command (a)
1491             continue
1492
1493         is_chord = n.get_maybe_exist_named_child ('chord')
1494         if not is_chord:
1495             try:
1496                 voice_builder.jumpto (n._when)
1497             except NegativeSkip, neg:
1498                 voice_builder.correct_negative_skip (n._when)
1499                 n.message (_ ("Negative skip found: from %s to %s, difference is %s") % (neg.here, neg.dest, neg.dest - neg.here))
1500
1501         if isinstance (n, musicxml.Attributes):
1502             if n.is_first () and n._measure_position == Rational (0):
1503                 try:
1504                     number = int (n.get_parent ().number)
1505                 except ValueError:
1506                     number = 0
1507                 if number > 0:
1508                     voice_builder.add_bar_check (number)
1509
1510             for a in musicxml_attributes_to_lily (n):
1511                 voice_builder.add_command (a)
1512             continue
1513
1514         if isinstance (n, musicxml.Barline):
1515             barlines = musicxml_barline_to_lily (n)
1516             for a in barlines:
1517                 if isinstance (a, musicexp.BarLine):
1518                     voice_builder.add_barline (a)
1519                 elif isinstance (a, RepeatMarker) or isinstance (a, EndingMarker):
1520                     voice_builder.add_command (a)
1521             continue
1522
1523         if not n.__class__.__name__ == 'Note':
1524             error_message (_ ('unexpected %s; expected %s or %s or %s') % (n, 'Note', 'Attributes', 'Barline'))
1525             continue
1526
1527         rest = n.get_maybe_exist_typed_child (musicxml.Rest)
1528         if (rest
1529             and rest.is_whole_measure ()):
1530
1531             voice_builder.add_multibar_rest (n._duration)
1532             continue
1533
1534         if n.is_first () and n._measure_position == Rational (0):
1535             try:
1536                 num = int (n.get_parent ().number)
1537             except ValueError:
1538                 num = 0
1539             if num > 0:
1540                 voice_builder.add_bar_check (num)
1541
1542         main_event = musicxml_note_to_lily_main_event (n)
1543         if main_event and not first_pitch:
1544             first_pitch = main_event.pitch
1545         ignore_lyrics = inside_slur or is_tied or is_chord
1546
1547         if main_event and hasattr (main_event, 'drum_type') and main_event.drum_type:
1548             modes_found['drummode'] = True
1549
1550         ev_chord = voice_builder.last_event_chord (n._when)
1551         if not ev_chord:
1552             ev_chord = musicexp.ChordEvent()
1553             voice_builder.add_music (ev_chord, n._duration)
1554
1555         grace = n.get_maybe_exist_typed_child (musicxml.Grace)
1556         if grace:
1557             grace_chord = None
1558             if n.get_maybe_exist_typed_child (musicxml.Chord) and ev_chord.grace_elements:
1559                 grace_chord = ev_chord.grace_elements.get_last_event_chord ()
1560             if not grace_chord:
1561                 grace_chord = musicexp.ChordEvent ()
1562                 ev_chord.append_grace (grace_chord)
1563             if hasattr (grace, 'slash'):
1564                 # TODO: use grace_type = "appoggiatura" for slurred grace notes
1565                 if grace.slash == "yes":
1566                     ev_chord.grace_type = "acciaccatura"
1567             # now that we have inserted the chord into the grace music, insert
1568             # everything into that chord instead of the ev_chord
1569             ev_chord = grace_chord
1570             ev_chord.append (main_event)
1571             ignore_lyrics = True
1572         else:
1573             ev_chord.append (main_event)
1574             # When a note/chord has grace notes (duration==0), the duration of the
1575             # event chord is not yet known, but the event chord was already added
1576             # with duration 0. The following correct this when we hit the real note!
1577             if voice_builder.current_duration () == 0 and n._duration > 0:
1578                 voice_builder.set_duration (n._duration)
1579
1580         notations_children = n.get_typed_children (musicxml.Notations)
1581         tuplet_event = None
1582         span_events = []
1583
1584         # The <notation> element can have the following children (+ means implemented, ~ partially, - not):
1585         # +tied | +slur | +tuplet | glissando | slide |
1586         #    ornaments | technical | articulations | dynamics |
1587         #    +fermata | arpeggiate | non-arpeggiate |
1588         #    accidental-mark | other-notation
1589         for notations in notations_children:
1590             for tuplet_event in notations.get_tuplets():
1591                 mod = n.get_maybe_exist_typed_child (musicxml.Time_modification)
1592                 frac = (1,1)
1593                 if mod:
1594                     frac = mod.get_fraction ()
1595
1596                 tuplet_events.append ((ev_chord, tuplet_event, frac))
1597
1598             slurs = [s for s in notations.get_named_children ('slur')
1599                 if s.get_type () in ('start','stop')]
1600             if slurs:
1601                 if len (slurs) > 1:
1602                     error_message (_ ('cannot have two simultaneous slurs'))
1603                 # record the slur status for the next note in the loop
1604                 if not grace:
1605                     if slurs[0].get_type () == 'start':
1606                         inside_slur = True
1607                     elif slurs[0].get_type () == 'stop':
1608                         inside_slur = False
1609                 lily_ev = musicxml_spanner_to_lily_event (slurs[0])
1610                 ev_chord.append (lily_ev)
1611
1612             if not grace:
1613                 mxl_tie = notations.get_tie ()
1614                 if mxl_tie and mxl_tie.type == 'start':
1615                     ev_chord.append (musicexp.TieEvent ())
1616                     is_tied = True
1617                 else:
1618                     is_tied = False
1619
1620             fermatas = notations.get_named_children ('fermata')
1621             for a in fermatas:
1622                 ev = musicxml_fermata_to_lily_event (a)
1623                 if ev:
1624                     ev_chord.append (ev)
1625
1626             arpeggiate = notations.get_named_children ('arpeggiate')
1627             for a in arpeggiate:
1628                 ev = musicxml_arpeggiate_to_lily_event (a)
1629                 if ev:
1630                     ev_chord.append (ev)
1631
1632             arpeggiate = notations.get_named_children ('non-arpeggiate')
1633             for a in arpeggiate:
1634                 ev = musicxml_nonarpeggiate_to_lily_event (a)
1635                 if ev:
1636                     ev_chord.append (ev)
1637
1638             glissandos = notations.get_named_children ('glissando')
1639             glissandos += notations.get_named_children ('slide')
1640             for a in glissandos:
1641                 ev = musicxml_spanner_to_lily_event (a)
1642                 if ev:
1643                     ev_chord.append (ev)
1644
1645             # Articulations can contain the following child elements:
1646             #         accent | strong-accent | staccato | tenuto |
1647             #         detached-legato | staccatissimo | spiccato |
1648             #         scoop | plop | doit | falloff | breath-mark |
1649             #         caesura | stress | unstress
1650             # Technical can contain the following child elements:
1651             #         up-bow | down-bow | harmonic | open-string |
1652             #         thumb-position | fingering | pluck | double-tongue |
1653             #         triple-tongue | stopped | snap-pizzicato | fret |
1654             #         string | hammer-on | pull-off | bend | tap | heel |
1655             #         toe | fingernails | other-technical
1656             # Ornaments can contain the following child elements:
1657             #         trill-mark | turn | delayed-turn | inverted-turn |
1658             #         shake | wavy-line | mordent | inverted-mordent |
1659             #         schleifer | tremolo | other-ornament, accidental-mark
1660             ornaments = notations.get_named_children ('ornaments')
1661             ornaments += notations.get_named_children ('articulations')
1662             ornaments += notations.get_named_children ('technical')
1663
1664             for a in ornaments:
1665                 for ch in a.get_all_children ():
1666                     ev = musicxml_articulation_to_lily_event (ch)
1667                     if ev:
1668                         ev_chord.append (ev)
1669
1670             dynamics = notations.get_named_children ('dynamics')
1671             for a in dynamics:
1672                 for ch in a.get_all_children ():
1673                     ev = musicxml_dynamics_to_lily_event (ch)
1674                     if ev:
1675                         ev_chord.append (ev)
1676
1677         # Extract the lyrics
1678         if not rest and not ignore_lyrics:
1679             note_lyrics_processed = []
1680             note_lyrics_elements = n.get_typed_children (musicxml.Lyric)
1681             for l in note_lyrics_elements:
1682                 if l.get_number () < 0:
1683                     for k in lyrics.keys ():
1684                         lyrics[k].append (l.lyric_to_text ())
1685                         note_lyrics_processed.append (k)
1686                 else:
1687                     lyrics[l.number].append(l.lyric_to_text ())
1688                     note_lyrics_processed.append (l.number)
1689             for lnr in lyrics.keys ():
1690                 if not lnr in note_lyrics_processed:
1691                     lyrics[lnr].append ("\skip4")
1692
1693
1694         mxl_beams = [b for b in n.get_named_children ('beam')
1695                      if (b.get_type () in ('begin', 'end')
1696                          and b.is_primary ())]
1697         if mxl_beams and not conversion_settings.ignore_beaming:
1698             beam_ev = musicxml_spanner_to_lily_event (mxl_beams[0])
1699             if beam_ev:
1700                 ev_chord.append (beam_ev)
1701
1702         if tuplet_event:
1703             mod = n.get_maybe_exist_typed_child (musicxml.Time_modification)
1704             frac = (1,1)
1705             if mod:
1706                 frac = mod.get_fraction ()
1707
1708             tuplet_events.append ((ev_chord, tuplet_event, frac))
1709
1710     ## force trailing mm rests to be written out.
1711     voice_builder.add_music (musicexp.ChordEvent (), Rational (0))
1712
1713     ly_voice = group_tuplets (voice_builder.elements, tuplet_events)
1714     ly_voice = group_repeats (ly_voice)
1715
1716     seq_music = musicexp.SequentialMusic ()
1717
1718     if 'drummode' in modes_found.keys ():
1719         ## \key <pitch> barfs in drummode.
1720         ly_voice = [e for e in ly_voice
1721                     if not isinstance(e, musicexp.KeySignatureChange)]
1722
1723     seq_music.elements = ly_voice
1724     for k in lyrics.keys ():
1725         return_value.lyrics_dict[k] = musicexp.Lyrics ()
1726         return_value.lyrics_dict[k].lyrics_syllables = lyrics[k]
1727
1728
1729     if len (modes_found) > 1:
1730        error_message (_ ('cannot simultaneously have more than one mode: %s') % modes_found.keys ())
1731
1732     if options.relative:
1733         v = musicexp.RelativeMusic ()
1734         v.element = seq_music
1735         v.basepitch = first_pitch
1736         seq_music = v
1737
1738     return_value.ly_voice = seq_music
1739     for mode in modes_found.keys ():
1740         v = musicexp.ModeChangingMusicWrapper()
1741         v.element = seq_music
1742         v.mode = mode
1743         return_value.ly_voice = v
1744
1745     return return_value
1746
1747 def musicxml_id_to_lily (id):
1748     digits = ['Zero', 'One', 'Two', 'Three', 'Four', 'Five',
1749               'Six', 'Seven', 'Eight', 'Nine', 'Ten']
1750
1751     for digit in digits:
1752         d = digits.index (digit)
1753         id = re.sub ('%d' % d, digit, id)
1754
1755     id = re.sub  ('[^a-zA-Z]', 'X', id)
1756     return id
1757
1758 def musicxml_pitch_to_lily (mxl_pitch):
1759     p = musicexp.Pitch ()
1760     p.alteration = mxl_pitch.get_alteration ()
1761     p.step = musicxml_step_to_lily (mxl_pitch.get_step ())
1762     p.octave = mxl_pitch.get_octave () - 4
1763     return p
1764
1765 def musicxml_unpitched_to_lily (mxl_unpitched):
1766     p = None
1767     step = mxl_unpitched.get_step ()
1768     if step:
1769         p = musicexp.Pitch ()
1770         p.step = musicxml_step_to_lily (step)
1771     octave = mxl_unpitched.get_octave ()
1772     if octave and p:
1773         p.octave = octave - 4
1774     return p
1775
1776 def musicxml_restdisplay_to_lily (mxl_rest):
1777     p = None
1778     step = mxl_rest.get_step ()
1779     if step:
1780         p = musicexp.Pitch ()
1781         p.step = musicxml_step_to_lily (step)
1782     octave = mxl_rest.get_octave ()
1783     if octave and p:
1784         p.octave = octave - 4
1785     return p
1786
1787 def voices_in_part (part):
1788     """Return a Name -> Voice dictionary for PART"""
1789     part.interpret ()
1790     part.extract_voices ()
1791     voices = part.get_voices ()
1792     part_info = part.get_staff_attributes ()
1793
1794     return (voices, part_info)
1795
1796 def voices_in_part_in_parts (parts):
1797     """return a Part -> Name -> Voice dictionary"""
1798     return dict([(p.id, voices_in_part (p)) for p in parts])
1799
1800
1801 def get_all_voices (parts):
1802     all_voices = voices_in_part_in_parts (parts)
1803
1804     all_ly_voices = {}
1805     all_ly_staffinfo = {}
1806     for p, (name_voice, staff_info) in all_voices.items ():
1807
1808         part_ly_voices = {}
1809         for n, v in name_voice.items ():
1810             progress (_ ("Converting to LilyPond expressions..."))
1811             # musicxml_voice_to_lily_voice returns (lily_voice, {nr->lyrics, nr->lyrics})
1812             part_ly_voices[n] = musicxml_voice_to_lily_voice (v)
1813
1814         all_ly_voices[p] = part_ly_voices
1815         all_ly_staffinfo[p] = staff_info
1816
1817     return (all_ly_voices, all_ly_staffinfo)
1818
1819
1820 def option_parser ():
1821     p = ly.get_option_parser (usage = _ ("musicxml2ly [options] FILE.xml"),
1822                              description = _ ("Convert %s to LilyPond input.") % 'MusicXML' + "\n",
1823                              add_help_option=False)
1824
1825     p.add_option("-h", "--help",
1826                  action="help",
1827                  help=_ ("show this help and exit"))
1828
1829     p.version = ('''%prog (LilyPond) @TOPLEVEL_VERSION@\n\n'''
1830                                       +
1831 _ ("""This program is free software.  It is covered by the GNU General Public
1832 License and you are welcome to change it and/or distribute copies of it
1833 under certain conditions.  Invoke as `%s --warranty' for more
1834 information.""") % 'lilypond'
1835 + """
1836 Copyright (c) 2005--2008 by
1837     Han-Wen Nienhuys <hanwen@xs4all.nl>,
1838     Jan Nieuwenhuizen <janneke@gnu.org> and
1839     Reinhold Kainhofer <reinhold@kainhofer.com>
1840 """)
1841     p.add_option("--version",
1842                  action="version",
1843                  help=_ ("show version number and exit"))
1844
1845     p.add_option ('-v', '--verbose',
1846                   action = "store_true",
1847                   dest = 'verbose',
1848                   help = _ ("be verbose"))
1849
1850     p.add_option ('', '--lxml',
1851                   action = "store_true",
1852                   default = False,
1853                   dest = "use_lxml",
1854                   help = _ ("use lxml.etree; uses less memory and cpu time"))
1855
1856     p.add_option ('-z', '--compressed',
1857                   action = "store_true",
1858                   dest = 'compressed',
1859                   default = False,
1860                   help = _ ("input file is a zip-compressed MusicXML file"))
1861
1862     p.add_option ('-r', '--relative',
1863                   action = "store_true",
1864                   default = True,
1865                   dest = "relative",
1866                   help = _ ("convert pitches in relative mode (default)"))
1867
1868     p.add_option ('-a', '--absolute',
1869                   action = "store_false",
1870                   dest = "relative",
1871                   help = _ ("convert pitches in absolute mode"))
1872
1873     p.add_option ('-l', '--language',
1874                   metavar = _ ("LANG"),
1875                   action = "store",
1876                   help = _ ("use a different language file 'LANG.ly' and corresponding pitch names, e.g. 'deutsch' for deutsch.ly"))
1877
1878     p.add_option ('--nd', '--no-articulation-directions',
1879                   action = "store_false",
1880                   default = True,
1881                   dest = "convert_directions",
1882                   help = _ ("do not convert directions (^, _ or -) for articulations, dynamics, etc."))
1883
1884     p.add_option ('-o', '--output',
1885                   metavar = _ ("FILE"),
1886                   action = "store",
1887                   default = None,
1888                   type = 'string',
1889                   dest = 'output_name',
1890                   help = _ ("set output filename to FILE"))
1891     p.add_option_group (ly.display_encode (_ ('Bugs')),
1892                         description = (_ ("Report bugs via")
1893                                      + ''' http://post.gmane.org/post.php'''
1894                                      '''?group=gmane.comp.gnu.lilypond.bugs\n'''))
1895     return p
1896
1897 def music_xml_voice_name_to_lily_name (part_id, name):
1898     str = "Part%sVoice%s" % (part_id, name)
1899     return musicxml_id_to_lily (str)
1900
1901 def music_xml_lyrics_name_to_lily_name (part_id, name, lyricsnr):
1902     str = "Part%sVoice%sLyrics%s" % (part_id, name, lyricsnr)
1903     return musicxml_id_to_lily (str)
1904
1905 def print_voice_definitions (printer, part_list, voices):
1906     for part in part_list:
1907         part_id = part.id
1908         nv_dict = voices.get (part_id, {})
1909         for (name, voice) in nv_dict.items ():
1910             k = music_xml_voice_name_to_lily_name (part_id, name)
1911             printer.dump ('%s = ' % k)
1912             voice.ly_voice.print_ly (printer)
1913             printer.newline()
1914             for l in voice.lyrics_order:
1915                 lname = music_xml_lyrics_name_to_lily_name (part_id, name, l)
1916                 printer.dump ('%s = ' %lname )
1917                 voice.lyrics_dict[l].print_ly (printer)
1918                 printer.newline()
1919
1920
1921 def uniq_list (l):
1922     return dict ([(elt,1) for elt in l]).keys ()
1923
1924 # format the information about the staff in the form
1925 #     [staffid,
1926 #         [
1927 #            [voiceid1, [lyricsid11, lyricsid12,...] ...],
1928 #            [voiceid2, [lyricsid21, lyricsid22,...] ...],
1929 #            ...
1930 #         ]
1931 #     ]
1932 # raw_voices is of the form [(voicename, lyricsids)*]
1933 def format_staff_info (part_id, staff_id, raw_voices):
1934     voices = []
1935     for (v, lyricsids) in raw_voices:
1936         voice_name = music_xml_voice_name_to_lily_name (part_id, v)
1937         voice_lyrics = [music_xml_lyrics_name_to_lily_name (part_id, v, l)
1938                    for l in lyricsids]
1939         voices.append ([voice_name, voice_lyrics])
1940     return [staff_id, voices]
1941
1942 def update_score_setup (score_structure, part_list, voices):
1943
1944     for part_definition in part_list:
1945         part_id = part_definition.id
1946         nv_dict = voices.get (part_id)
1947         if not nv_dict:
1948             error_message (_ ('unknown part in part-list: %s') % part_id)
1949             continue
1950
1951         staves = reduce (lambda x,y: x+ y,
1952                 [voice.voicedata._staves.keys ()
1953                  for voice in nv_dict.values ()],
1954                 [])
1955         staves_info = []
1956         if len (staves) > 1:
1957             staves_info = []
1958             staves = uniq_list (staves)
1959             staves.sort ()
1960             for s in staves:
1961                 thisstaff_raw_voices = [(voice_name, voice.lyrics_order)
1962                     for (voice_name, voice) in nv_dict.items ()
1963                     if voice.voicedata._start_staff == s]
1964                 staves_info.append (format_staff_info (part_id, s, thisstaff_raw_voices))
1965         else:
1966             thisstaff_raw_voices = [(voice_name, voice.lyrics_order)
1967                 for (voice_name, voice) in nv_dict.items ()]
1968             staves_info.append (format_staff_info (part_id, None, thisstaff_raw_voices))
1969         score_structure.set_part_information (part_id, staves_info)
1970
1971 def print_ly_preamble (printer, filename):
1972     printer.dump_version ()
1973     printer.print_verbatim ('%% automatically converted from %s\n' % filename)
1974
1975 def print_ly_additional_definitions (printer, filename):
1976     if needed_additional_definitions:
1977         printer.newline ()
1978         printer.print_verbatim ('%% additional definitions required by the score:')
1979         printer.newline ()
1980     for a in set(needed_additional_definitions):
1981         printer.print_verbatim (additional_definitions.get (a, ''))
1982         printer.newline ()
1983     printer.newline ()
1984
1985 # Read in the tree from the given I/O object (either file or string) and
1986 # demarshall it using the classes from the musicxml.py file
1987 def read_xml (io_object, use_lxml):
1988     if use_lxml:
1989         import lxml.etree
1990         tree = lxml.etree.parse (io_object)
1991         mxl_tree = musicxml.lxml_demarshal_node (tree.getroot ())
1992         return mxl_tree
1993     else:
1994         from xml.dom import minidom, Node
1995         doc = minidom.parse(io_object)
1996         node = doc.documentElement
1997         return musicxml.minidom_demarshal_node (node)
1998     return None
1999
2000
2001 def read_musicxml (filename, compressed, use_lxml):
2002     raw_string = None
2003     if compressed:
2004         progress (_ ("Input file %s is compressed, extracting raw MusicXML data") % filename)
2005         z = zipfile.ZipFile (filename, "r")
2006         container_xml = z.read ("META-INF/container.xml")
2007         if not container_xml:
2008             return None
2009         container = read_xml (StringIO.StringIO (container_xml), use_lxml)
2010         if not container:
2011             return None
2012         rootfiles = container.get_maybe_exist_named_child ('rootfiles')
2013         if not rootfiles:
2014             return None
2015         rootfile_list = rootfiles.get_named_children ('rootfile')
2016         mxml_file = None
2017         if len (rootfile_list) > 0:
2018             mxml_file = getattr (rootfile_list[0], 'full-path', None)
2019         if mxml_file:
2020             raw_string = z.read (mxml_file)
2021
2022     io_object = filename
2023     if raw_string:
2024         io_object = StringIO.StringIO (raw_string)
2025
2026     return read_xml (io_object, use_lxml)
2027
2028
2029 def convert (filename, options):
2030     progress (_ ("Reading MusicXML from %s ...") % filename)
2031
2032     tree = read_musicxml (filename, options.compressed, options.use_lxml)
2033     score_information = extract_score_information (tree)
2034     layout_information = extract_layout_information (tree)
2035
2036     parts = tree.get_typed_children (musicxml.Part)
2037     (voices, staff_info) = get_all_voices (parts)
2038
2039     score_structure = None
2040     mxl_pl = tree.get_maybe_exist_typed_child (musicxml.Part_list)
2041     if mxl_pl:
2042         score_structure = extract_score_layout (mxl_pl, staff_info)
2043         part_list = mxl_pl.get_named_children ("score-part")
2044
2045     # score information is contained in the <work>, <identification> or <movement-title> tags
2046     update_score_setup (score_structure, part_list, voices)
2047
2048     if not options.output_name:
2049         options.output_name = os.path.basename (filename)
2050         options.output_name = os.path.splitext (options.output_name)[0]
2051     elif re.match (".*\.ly", options.output_name):
2052         options.output_name = os.path.splitext (options.output_name)[0]
2053
2054
2055     defs_ly_name = options.output_name + '-defs.ly'
2056     driver_ly_name = options.output_name + '.ly'
2057
2058     printer = musicexp.Output_printer()
2059     progress (_ ("Output to `%s'") % defs_ly_name)
2060     printer.set_file (codecs.open (defs_ly_name, 'wb', encoding='utf-8'))
2061
2062     print_ly_preamble (printer, filename)
2063     print_ly_additional_definitions (printer, filename)
2064     if score_information:
2065         score_information.print_ly (printer)
2066     if layout_information:
2067         layout_information.print_ly (printer)
2068     print_voice_definitions (printer, part_list, voices)
2069
2070     printer.close ()
2071
2072
2073     progress (_ ("Output to `%s'") % driver_ly_name)
2074     printer = musicexp.Output_printer()
2075     printer.set_file (codecs.open (driver_ly_name, 'wb', encoding='utf-8'))
2076     print_ly_preamble (printer, filename)
2077     printer.dump (r'\include "%s"' % os.path.basename (defs_ly_name))
2078     score_structure.print_ly (printer)
2079     printer.newline ()
2080
2081     return voices
2082
2083 def get_existing_filename_with_extension (filename, ext):
2084     if os.path.exists (filename):
2085         return filename
2086     newfilename = filename + "." + ext
2087     if os.path.exists (newfilename):
2088         return newfilename;
2089     newfilename = filename + ext
2090     if os.path.exists (newfilename):
2091         return newfilename;
2092     return ''
2093
2094 def main ():
2095     opt_parser = option_parser()
2096
2097     global options
2098     (options, args) = opt_parser.parse_args ()
2099     if not args:
2100         opt_parser.print_usage()
2101         sys.exit (2)
2102
2103     if options.language:
2104         musicexp.set_pitch_language (options.language)
2105         needed_additional_definitions.append (options.language)
2106         additional_definitions[options.language] = "\\include \"%s.ly\"\n" % options.language
2107
2108     # Allow the user to leave out the .xml or xml on the filename
2109     filename = get_existing_filename_with_extension (args[0], "xml")
2110     if not filename:
2111         filename = get_existing_filename_with_extension (args[0], "mxl")
2112         options.compressed = True
2113     if filename and os.path.exists (filename):
2114         voices = convert (filename, options)
2115     else:
2116         progress (_ ("Unable to find input file %s") % args[0])
2117
2118 if __name__ == '__main__':
2119     main()