X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=scripts%2Fmusicxml2ly.py;h=9b99d3abd0897182f3a608ba6261fe8e10041465;hb=61efd132a32f0ccad56b4f56bf7a795ab9e39073;hp=b81c9e8344976325d307f526f65fbff66ed71a96;hpb=a596fd93b1cd7f6f6e49dc84a25b79695be983e3;p=lilypond.git diff --git a/scripts/musicxml2ly.py b/scripts/musicxml2ly.py index b81c9e8344..9b99d3abd0 100644 --- a/scripts/musicxml2ly.py +++ b/scripts/musicxml2ly.py @@ -62,22 +62,28 @@ def extract_score_information (tree): return header +class PartGroupInfo: + def __init__ (self): + self.start = {} + self.end = {} + def is_empty (self): + return len (self.start) + len (self.end) == 0 + def add_start (self, g): + self.start[getattr (g, 'number', "1")] = g + def add_end (self, g): + self.end[getattr (g, 'number', "1")] = g + def print_ly (self, printer): + error_message ("Unprocessed PartGroupInfo %s encountered" % self) + def ly_expression (self): + error_message ("Unprocessed PartGroupInfo %s encountered" % self) + return '' + def extract_score_layout (part_list): layout = musicexp.StaffGroup (None) - currentgroups_dict = {} - currentgroups = [] if not part_list: return layout - def insert_into_layout (object): - if len (currentgroups) > 0: - group_to_insert = currentgroups_dict.get (currentgroups [-1], layout) - else: - group_to_insert = layout - group_to_insert.appendStaff (object) - return group_to_insert - def read_score_part (el): if not isinstance (el, musicxml.Score_part): return @@ -92,48 +98,110 @@ def extract_score_layout (part_list): # TODO: Read in the MIDI device / instrument return staff + def read_score_group (el): + if not isinstance (el, musicxml.Part_group): + return + group = musicexp.StaffGroup () + if hasattr (el, 'number'): + id = el.number + group.id = id + #currentgroups_dict[id] = group + #currentgroups.append (id) + if el.get_maybe_exist_named_child ('group-name'): + group.instrument_name = el.get_maybe_exist_named_child ('group-name').get_text () + if el.get_maybe_exist_named_child ('group-abbreviation'): + group.short_instrument_name = el.get_maybe_exist_named_child ('group-abbreviation').get_text () + if el.get_maybe_exist_named_child ('group-symbol'): + group.symbol = el.get_maybe_exist_named_child ('group-symbol').get_text () + if el.get_maybe_exist_named_child ('group-barline'): + group.spanbar = el.get_maybe_exist_named_child ('group-barline').get_text () + return group + parts_groups = part_list.get_all_children () - # the start/end group tags are not necessarily ordered correctly, so - # we can't go through the children sequentially! - if len (parts_groups) == 1 and isinstance (parts_group[1], musicxml.Score_part): - return read_score_part (parts_group[1]) + # the start/end group tags are not necessarily ordered correctly and groups + # might even overlap, so we can't go through the children sequentially! + # 1) Replace all Score_part objects by their corresponding Staff objects, + # also collect all group start/stop points into one PartGroupInfo object + staves = [] + group_info = PartGroupInfo () for el in parts_groups: if isinstance (el, musicxml.Score_part): - staff = read_score_part (el) - insert_into_layout (staff) + if not group_info.is_empty (): + staves.append (group_info) + group_info = PartGroupInfo () + staves.append (read_score_part (el)) elif isinstance (el, musicxml.Part_group): if el.type == "start": - group = musicexp.StaffGroup () - staff_group = insert_into_layout (group) - # If we're inserting a nested staffgroup, we need to use InnerStaffGroup - if staff_group != layout: - group.stafftype = "InnerStaffGroup" - if hasattr (el, 'number'): - id = el.number - group.id = id - currentgroups_dict[id] = group - currentgroups.append (id) - if el.get_maybe_exist_named_child ('group-name'): - group.instrument_name = el.get_maybe_exist_named_child ('group-name').get_text () - if el.get_maybe_exist_named_child ('group-abbreviation'): - group.short_instrument_name = el.get_maybe_exist_named_child ('group-abbreviation').get_text () - if el.get_maybe_exist_named_child ('group-symbol'): - group.symbol = el.get_maybe_exist_named_child ('group-symbol').get_text () - if el.get_maybe_exist_named_child ('group-barline'): - group.spanbar = el.get_maybe_exist_named_child ('group-barline').get_text () - + group_info.add_start (el) elif el.type == "stop": - # end the part-group, i.e. simply remove it from the lists - if hasattr (el, 'number'): - pid = el.number - elif len (currentgroups) > 0: - pid = el[-1] - if pid: - del currentgroups_dict[pid] - currentgroups.remove (pid) + group_info.add_end (el) + if not group_info.is_empty (): + staves.append (group_info) + + # 2) Now, detect the groups: + group_starts = [] + pos = 0 + while pos < len (staves): + el = staves[pos] + if isinstance (el, PartGroupInfo): + prev_start = 0 + if len (group_starts) > 0: + prev_start = group_starts[-1] + elif len (el.end) > 0: # no group to end here + el.end = {} + if len (el.end) > 0: # closes an existing group + ends = el.end.keys () + prev_started = staves[prev_start].start.keys () + grpid = None + intersection = filter(lambda x:x in ends, prev_started) + if len (intersection) > 0: + grpid = intersection[0] + else: + # Close the last started group + grpid = staves[prev_start].start.keys () [0] + # Find the corresponding closing tag and remove it! + j = pos + 1 + foundclosing = False + while j < len (staves) and not foundclosing: + if isinstance (staves[j], PartGroupInfo) and staves[j].end.has_key (grpid): + foundclosing = True + del staves[j].end[grpid] + if staves[j].is_empty (): + del staves[j] + j += 1 + grpobj = staves[prev_start].start[grpid] + group = read_score_group (grpobj) + # remove the id from both the start and end + if el.end.has_key (grpid): + del el.end[grpid] + del staves[prev_start].start[grpid] + if el.is_empty (): + del staves[pos] + # replace the staves with the whole group + for j in staves[(prev_start + 1):pos]: + if j.is_group: + j.stafftype = "InnerStaffGroup" + group.append_staff (j) + del staves[(prev_start + 1):pos] + staves.insert (prev_start + 1, group) + # reset pos so that we continue at the correct position + pos = prev_start + # remove an empty start group + if staves[prev_start].is_empty (): + del staves[prev_start] + group_starts.remove (prev_start) + pos -= 1 + elif len (el.start) > 0: # starts new part groups + group_starts.append (pos) + pos += 1 + + if len (staves) == 1: + return staves[0] + for i in staves: + layout.append_staff (i) return layout @@ -179,13 +247,13 @@ def musicxml_partial_to_lily (partial_len): def group_repeats (music_list): repeat_replaced = True music_start = 0 - i=0 + i = 0 # Walk through the list of expressions, looking for repeat structure # (repeat start/end, corresponding endings). If we find one, try to find the # last event of the repeat, replace the whole structure and start over again. # For nested repeats, as soon as we encounter another starting repeat bar, # treat that one first, and start over for the outer repeat. - while repeat_replaced and i<10: + while repeat_replaced and i < 100: i += 1 repeat_start = -1 # position of repeat start / end repeat_end = -1 # position of repeat start / end @@ -193,6 +261,7 @@ def group_repeats (music_list): ending_start = -1 # position of current ending start endings = [] # list of already finished endings pos = 0 + last = len (music_list) - 1 repeat_replaced = False final_marker = 0 while pos < len (music_list) and not repeat_replaced: @@ -219,6 +288,7 @@ def group_repeats (music_list): if e.direction == -1: if repeat_start < 0: repeat_start = 0 + if repeat_end < 0: repeat_end = pos ending_start = pos elif e.direction == 1: @@ -234,6 +304,17 @@ def group_repeats (music_list): if repeat_start >= 0 and repeat_end > 0 and ending_start < 0: repeat_finished = True + # Finish off all repeats without explicit ending bar (e.g. when + # we convert only one page of a multi-page score with repeats) + if pos == last and repeat_start >= 0: + repeat_finished = True + final_marker = pos + if repeat_end < 0: + repeat_end = pos + if ending_start >= 0: + endings.append ([ending_start, pos]) + ending_start = -1 + if repeat_finished: # We found the whole structure replace it! r = musicexp.RepeatedMusic () @@ -405,18 +486,18 @@ def musicxml_barline_to_lily (barline): repeat.times = 2 repeat.event = barline if repeat.direction == -1: - retval[1] = repeat - else: retval[3] = repeat + else: + retval[1] = repeat if ending_element and hasattr (ending_element, 'type'): ending = EndingMarker () ending.direction = {"start": -1, "stop": 1, "discontinue": 1}.get (ending_element.type, 0) ending.event = barline if ending.direction == -1: - retval[0] = ending - else: retval[4] = ending + else: + retval[0] = ending if bartype: b = musicexp.BarLine () @@ -487,6 +568,13 @@ def musicxml_fermata_to_lily_event (mxl_event): ev.force_direction = dir return ev + +def musicxml_arpeggiate_to_lily_event (mxl_event): + ev = musicexp.ArpeggioEvent () + ev.direction = {"up": 1, "down": -1}.get (getattr (mxl_event, 'direction', None), 0) + return ev + + def musicxml_tremolo_to_lily_event (mxl_event): ev = musicexp.TremoloEvent () ev.bars = mxl_event.get_text () @@ -503,6 +591,11 @@ def musicxml_fingering_event (mxl_event): ev.type = mxl_event.get_text () return ev +def musicxml_string_event (mxl_event): + ev = musicexp.NoDirectionArticulationEvent () + ev.type = mxl_event.get_text () + return ev + def musicxml_accidental_mark (mxl_event): ev = musicexp.MarkupEvent () contents = { "sharp": "\\sharp", @@ -532,13 +625,13 @@ def musicxml_accidental_mark (mxl_event): # -) (class, name) (like string, only that a different class than ArticulationEvent is used) # TODO: Some translations are missing! articulations_dict = { - "accent": (musicexp.ShortArticulationEvent, ">"), + "accent": (musicexp.ShortArticulationEvent, ">"), # or "accent" "accidental-mark": musicxml_accidental_mark, "bend": musicxml_bend_to_lily_event, "breath-mark": (musicexp.NoDirectionArticulationEvent, "breathe"), #"caesura": "caesura", #"delayed-turn": "?", - #"detached-legato": "", + "detached-legato": (musicexp.ShortArticulationEvent, "_"), # or "portato" #"doit": "", #"double-tongue": "", "down-bow": "downbow", @@ -552,24 +645,23 @@ articulations_dict = { "inverted-mordent": "prall", "inverted-turn": "reverseturn", "mordent": "mordent", - #"open-string": "", + "open-string": "open", #"plop": "", #"pluck": "", - #"portato": (musicexp.ShortArticulationEvent, "_"), # does not exist in MusicXML #"pull-off": "", #"schleifer": "?", #"scoop": "", #"shake": "?", #"snap-pizzicato": "", #"spiccato": "", - "staccatissimo": (musicexp.ShortArticulationEvent, "|"), - "staccato": (musicexp.ShortArticulationEvent, "."), - "stopped": (musicexp.ShortArticulationEvent, "+"), + "staccatissimo": (musicexp.ShortArticulationEvent, "|"), # or "staccatissimo" + "staccato": (musicexp.ShortArticulationEvent, "."), # or "staccato" + "stopped": (musicexp.ShortArticulationEvent, "+"), # or "stopped" #"stress": "", - #"string": "", - "strong-accent": (musicexp.ShortArticulationEvent, "^"), + "string": musicxml_string_event, + "strong-accent": (musicexp.ShortArticulationEvent, "^"), # or "marcato" #"tap": "", - "tenuto": (musicexp.ShortArticulationEvent, "-"), + "tenuto": (musicexp.ShortArticulationEvent, "-"), # or "tenuto" #"thumb-position": "", #"toe": "", "turn": "turn", @@ -725,6 +817,40 @@ def musicxml_direction_to_lily (n): return res +def musicxml_frame_to_lily_event (frame): + ev = musicexp.FretEvent () + ev.strings = frame.get_strings () + ev.frets = frame.get_frets () + #offset = frame.get_first_fret () - 1 + barre = [] + for fn in frame.get_named_children ('frame-note'): + fret = fn.get_fret () + if fret <= 0: + fret = "o" + el = [ fn.get_string (), fret ] + fingering = fn.get_fingering () + if fingering >= 0: + el.append (fingering) + ev.elements.append (el) + b = fn.get_barre () + if b == 'start': + barre[0] = el[0] # start string + barre[2] = el[1] # fret + elif b == 'stop': + barre[1] = el[0] # end string + if barre: + ev.barre = barre + return ev + +def musicxml_harmony_to_lily (n): + res = [] + for f in n.get_named_children ('frame'): + ev = musicxml_frame_to_lily_event (f) + if ev: + res.append (ev) + + return res + instrument_drumtype_dict = { 'Acoustic Snare Drum': 'acousticsnare', 'Side Stick': 'sidestick', @@ -851,7 +977,7 @@ class LilyPondVoiceBuilder: error_message ('Negative skip %s' % diff) diff = Rational (0) - if diff > Rational (0) and not self.ignore_skips: + if diff > Rational (0) and not (self.ignore_skips and moment == 0): skip = musicexp.SkipEvent() skip.duration.duration_log = 0 skip.duration.factor = diff @@ -889,11 +1015,21 @@ class LilyPondVoiceBuilder: self.begin_moment = goto evc = musicexp.EventChord () self.elements.append (evc) - + + +class VoiceData: + def __init__ (self): + self.voicedata = None + self.ly_voice = None + self.lyrics_dict = {} + self.lyrics_order = [] + def musicxml_voice_to_lily_voice (voice): tuplet_events = [] modes_found = {} lyrics = {} + return_value = VoiceData () + return_value.voicedata = voice # Needed for melismata detection (ignore lyrics on those notes!): inside_slur = False @@ -901,10 +1037,13 @@ def musicxml_voice_to_lily_voice (voice): is_chord = False ignore_lyrics = False + current_staff = None + # TODO: Make sure that the keys in the dict don't get reordered, since # we need the correct ordering of the lyrics stanzas! By default, # a dict will reorder its keys - for k in voice.get_lyrics_numbers (): + return_value.lyrics_order = voice.get_lyrics_numbers () + for k in return_value.lyrics_order: lyrics[k] = [] voice_builder = LilyPondVoiceBuilder() @@ -912,6 +1051,12 @@ def musicxml_voice_to_lily_voice (voice): for n in voice._elements: if n.get_name () == 'forward': continue + staff = n.get_maybe_exist_named_child ('staff') + if staff: + staff = staff.get_text () + if current_staff and staff <> current_staff and not n.get_maybe_exist_named_child ('chord'): + voice_builder.add_command (musicexp.StaffChange (staff)) + current_staff = staff if isinstance (n, musicxml.Partial) and n.partial > 0: a = musicxml_partial_to_lily (n.partial) @@ -926,7 +1071,15 @@ def musicxml_voice_to_lily_voice (voice): else: voice_builder.add_command (a) continue - + + if isinstance (n, musicxml.Harmony): + for a in musicxml_harmony_to_lily (n): + if a.wait_for_note (): + voice_builder.add_dynamics (a) + else: + voice_builder.add_command (a) + continue + is_chord = n.get_maybe_exist_named_child ('chord') if not is_chord: try: @@ -1015,7 +1168,7 @@ def musicxml_voice_to_lily_voice (voice): if voice_builder.current_duration () == 0 and n._duration > 0: voice_builder.set_duration (n._duration) - notations = n.get_maybe_exist_typed_child (musicxml.Notations) + notations_children = n.get_typed_children (musicxml.Notations) tuplet_event = None span_events = [] @@ -1024,7 +1177,7 @@ def musicxml_voice_to_lily_voice (voice): # ornaments | technical | articulations | dynamics | # +fermata | arpeggiate | non-arpeggiate | # accidental-mark | other-notation - if notations: + for notations in notations_children: if notations.get_tuplet(): tuplet_event = notations.get_tuplet() mod = n.get_maybe_exist_typed_child (musicxml.Time_modification) @@ -1040,17 +1193,21 @@ def musicxml_voice_to_lily_voice (voice): if len (slurs) > 1: error_message ('more than 1 slur?') # record the slur status for the next note in the loop - if slurs[0].get_type () == 'start': - inside_slur = True - elif slurs[0].get_type () == 'stop': - inside_slur = False + if not grace: + if slurs[0].get_type () == 'start': + inside_slur = True + elif slurs[0].get_type () == 'stop': + inside_slur = False lily_ev = musicxml_spanner_to_lily_event (slurs[0]) ev_chord.append (lily_ev) - mxl_tie = notations.get_tie () - if mxl_tie and mxl_tie.type == 'start': - ev_chord.append (musicexp.TieEvent ()) - is_tied = True + if not grace: + mxl_tie = notations.get_tie () + if mxl_tie and mxl_tie.type == 'start': + ev_chord.append (musicexp.TieEvent ()) + is_tied = True + else: + is_tied = False fermatas = notations.get_named_children ('fermata') for a in fermatas: @@ -1060,7 +1217,9 @@ def musicxml_voice_to_lily_voice (voice): arpeggiate = notations.get_named_children ('arpeggiate') for a in arpeggiate: - ev_chord.append (musicexp.ArpeggioEvent ()) + ev = musicxml_arpeggiate_to_lily_event (a) + if ev: + ev_chord.append (ev) glissandos = notations.get_named_children ('glissando') for a in glissandos: @@ -1153,23 +1312,22 @@ def musicxml_voice_to_lily_voice (voice): if not isinstance(e, musicexp.KeySignatureChange)] seq_music.elements = ly_voice - lyrics_dict = {} for k in lyrics.keys (): - lyrics_dict[k] = musicexp.Lyrics () - lyrics_dict[k].lyrics_syllables = lyrics[k] + return_value.lyrics_dict[k] = musicexp.Lyrics () + return_value.lyrics_dict[k].lyrics_syllables = lyrics[k] if len (modes_found) > 1: error_message ('Too many modes found %s' % modes_found.keys ()) - return_value = seq_music + return_value.ly_voice = seq_music for mode in modes_found.keys (): v = musicexp.ModeChangingMusicWrapper() - v.element = return_value + v.element = seq_music v.mode = mode - return_value = v + return_value.ly_voice = v - return (return_value, lyrics_dict) + return return_value def musicxml_id_to_lily (id): @@ -1225,7 +1383,7 @@ def get_all_voices (parts): for n, v in name_voice.items (): progress ("Converting to LilyPond expressions...") # musicxml_voice_to_lily_voice returns (lily_voice, {nr->lyrics, nr->lyrics}) - part_ly_voices[n] = (musicxml_voice_to_lily_voice (v), v) + part_ly_voices[n] = musicxml_voice_to_lily_voice (v) all_ly_voices[p] = part_ly_voices @@ -1285,16 +1443,17 @@ def print_voice_definitions (printer, part_list, voices): for part in part_list: (p, nv_dict) = part_dict.get (part.id, (None, {})) - for (name, ((voice, lyrics), mxlvoice)) in nv_dict.items (): + #for (name, ((voice, lyrics), mxlvoice)) in nv_dict.items (): + for (name, voice) in nv_dict.items (): k = music_xml_voice_name_to_lily_name (p, name) printer.dump ('%s = ' % k) - voice.print_ly (printer) + voice.ly_voice.print_ly (printer) printer.newline() - - for l in lyrics.keys (): + + for l in voice.lyrics_order: lname = music_xml_lyrics_name_to_lily_name (p, name, l) printer.dump ('%s = ' %lname ) - lyrics[l].print_ly (printer) + voice.lyrics_dict[l].print_ly (printer) printer.newline() @@ -1309,13 +1468,13 @@ def uniq_list (l): # ... # ] # ] -# raw_voices is of the form [(voicename, lyrics)*] +# raw_voices is of the form [(voicename, lyricsids)*] def format_staff_info (part, staff_id, raw_voices): voices = [] - for (v, lyrics) in raw_voices: + for (v, lyricsids) in raw_voices: voice_name = music_xml_voice_name_to_lily_name (part, v) voice_lyrics = [music_xml_lyrics_name_to_lily_name (part, v, l) - for l in lyrics.keys ()] + for l in lyricsids] voices.append ([voice_name, voice_lyrics]) return [staff_id, voices] @@ -1332,8 +1491,8 @@ def update_score_setup (score_structure, part_list, voices): nv_dict = voices.get (part) staves = reduce (lambda x,y: x+ y, - [mxlvoice._staves.keys () - for (v, mxlvoice) in nv_dict.values ()], + [voice.voicedata._staves.keys () + for voice in nv_dict.values ()], []) staves_info = [] if len (staves) > 1: @@ -1341,15 +1500,15 @@ def update_score_setup (score_structure, part_list, voices): staves = uniq_list (staves) staves.sort () for s in staves: - thisstaff_raw_voices = [(voice_name, lyrics) - for (voice_name, ((music, lyrics), mxlvoice)) in nv_dict.items () - if mxlvoice._start_staff == s] + thisstaff_raw_voices = [(voice_name, voice.lyrics_order) + for (voice_name, voice) in nv_dict.items () + if voice.voicedata._start_staff == s] staves_info.append (format_staff_info (part, s, thisstaff_raw_voices)) else: - thisstaff_raw_voices = [(voice_name, lyrics) - for (voice_name, ((music, lyrics), mxlvoice)) in nv_dict.items ()] + thisstaff_raw_voices = [(voice_name, voice.lyrics_order) + for (voice_name, voice) in nv_dict.items ()] staves_info.append (format_staff_info (part, None, thisstaff_raw_voices)) - score_structure.setPartInformation (part_name, staves_info) + score_structure.set_part_information (part_name, staves_info) def print_ly_preamble (printer, filename): printer.dump_version ()