Mercurial > dottes
diff abc2xml/abc2xml.py @ 484:4fab69a1027d build-default-207
Add MusicXML conversion to tune pages.
Might help someone.
| author | Jim Hague <jim.hague@acm.org> |
|---|---|
| date | Tue, 17 Jun 2014 09:11:38 +0100 |
| parents | |
| children | b1dbb76f4eb9 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/abc2xml/abc2xml.py Tue Jun 17 09:11:38 2014 +0100 @@ -0,0 +1,1747 @@ +# coding=latin-1 +''' +Copyright (C) 2012: Willem G. Vree +Contributions: Nils Liberg, Nicolas Froment, Norman Schmidt, Reinier Maliepaard, Martin Tarenskeen + +This program is free software; you can redistribute it and/or modify it under the terms of the +GNU General Public License as published by the Free Software Foundation; either version 2 of +the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; +without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +See the GNU General Public License for more details. <http://www.gnu.org/licenses/gpl.html>. +''' + +from pyparsing import Word, OneOrMore, Optional, Literal, NotAny, MatchFirst +from pyparsing import Group, oneOf, Suppress, ZeroOrMore, Combine, FollowedBy +from pyparsing import srange, CharsNotIn, StringEnd, LineEnd, White, Regex +from pyparsing import nums, alphas, alphanums, ParseException, Forward +try: import xml.etree.cElementTree as E +except: import xml.etree.ElementTree as E +import types, sys, os, re, datetime + +VERSION = 58 + +def info (s, warn=1): + x = (warn and '-- ' or '') + s + try: sys.stderr.write (x + '\n') + except: sys.stderr.write (repr (x) + '\n') + +def abc_grammar (): # header, voice and lyrics grammar for ABC + b1 = Word (u"-,'<>\u2019#", exact=1) # catch misplaced chars in chords + + #----------------------------------------------------------------- + # ABC header (fld_text elements are matched later with reg. epr's) + #----------------------------------------------------------------- + + number = Word (nums).setParseAction (lambda t: int (t[0])) + field_str = Regex (r'(?:\\.|[^]\\])*') # match anything until end of field, skip escaped \] + field_str.setParseAction (lambda t: t[0].strip ()) # and strip spacing + + userdef_symbol = Word (srange ('[H-Wh-w~]'), exact=1) + fieldId = oneOf ('K L M Q P I T C O A Z N G H R B D F S E r') # info fields + X_field = Literal ('X') + Suppress (':') + number + field_str + U_field = Literal ('U') + Suppress (':') + userdef_symbol + Suppress ('=') + field_str + V_field = Literal ('V') + Suppress (':') + Word (alphanums + '_') + field_str + inf_fld = fieldId + Suppress (':') + field_str + ifield = Suppress ('[') + (X_field | U_field | V_field | inf_fld) + Suppress (']') + abc_header = OneOrMore (ifield) + StringEnd () + + #--------------------------------------------------------------------------------- + # I:score with recursive part groups and {* grand staff marker + #--------------------------------------------------------------------------------- + + voiceId = Suppress (Optional ('*')) + Word (alphanums + '_') + voice_gr = Suppress ('(') + OneOrMore (voiceId | Suppress ('|')) + Suppress (')') + simple_part = voiceId | voice_gr | Suppress ('|') + grand_staff = oneOf ('{* {') + OneOrMore (simple_part) + Suppress ('}') + part = Forward () + part_seq = OneOrMore (part | Suppress ('|')) + brace_gr = Suppress ('{') + part_seq + Suppress ('}') + bracket_gr = Suppress ('[') + part_seq + Suppress ('\]') # closing brackets are escaped by splitHeaderVoices + part << MatchFirst (simple_part | grand_staff | brace_gr | bracket_gr | Suppress ('|')) + abc_scoredef = Suppress (oneOf ('staves score')) + OneOrMore (part) + + #--------------------------------------------------------------------------------- + # ABC voice (not white space sensitive, beams detected in note/rest parse actions) + #--------------------------------------------------------------------------------- + + inline_field = Suppress ('[') + (inf_fld | U_field | V_field) + Suppress (']') + + note_length = Optional (number, 1) + Group (ZeroOrMore ('/')) + Optional (number, 2) + octaveHigh = OneOrMore ("'").setParseAction (lambda t: len(t)) + octaveLow = OneOrMore (',').setParseAction (lambda t: -len(t)) + octave = octaveHigh | octaveLow + + basenote = oneOf ('C D E F G A B c d e f g a b y') # includes spacer for parse efficiency + accidental = oneOf ('^^ __ ^ _ =') + rest_sym = oneOf ('x X z Z') + slur_beg = oneOf ('( .(') + ~Word (nums) # no tuplet_start + slur_ends = OneOrMore (oneOf (') .)')) + + long_decoration = Combine (oneOf ('! +') + CharsNotIn ('!+ \n') + oneOf ('! +')) + staccato = Literal ('.') + ~Literal ('|') # avoid dotted barline + decoration = staccato | userdef_symbol | long_decoration | slur_beg + decorations = OneOrMore (decoration) + staff_decos = decorations + ~oneOf (': | [|] []') + + tie = oneOf ('.- -') + rest = Optional (accidental) + rest_sym + note_length + pitch = Optional (accidental) + basenote + Optional (octave, 0) + note = pitch + note_length + Optional (tie) + Optional (slur_ends) + chord_note = Optional (decorations) + pitch + note_length + Optional (tie) + Optional (slur_ends) + chord_notes = OneOrMore (chord_note | rest | b1) + grace_notes = Forward () + chord = Suppress ('[') + OneOrMore (chord_notes | grace_notes) + Suppress (']') + note_length + Optional (tie) + Optional (slur_ends) + stem = note | chord | rest + + broken = Combine (OneOrMore ('<') | OneOrMore ('>')) + + tuplet_num = Suppress ('(') + number + tuplet_into = Suppress (':') + Optional (number, 0) + tuplet_notes = Suppress (':') + Optional (number, 0) + tuplet_start = tuplet_num + Optional (tuplet_into + Optional (tuplet_notes)) + + acciaccatura = Literal ('/') + grace_stem = Optional (decorations) + stem + grace_notes << Group (Suppress ('{') + Optional (acciaccatura) + OneOrMore (grace_stem) + Suppress ('}')) + + text_expression = Optional (oneOf ('^ _ < > @'), '^') + Optional (CharsNotIn ('"'), "") + chord_accidental = oneOf ('# b =') + triad = oneOf ('ma Maj maj M mi min m aug dim o + -') + seventh = oneOf ('7 ma7 Maj7 M7 maj7 mi7 m7 dim7 o7 -7 aug7 +7 m7b5 mi7b5') + sixth = oneOf ('6 ma6 M6 m6 mi6') + ninth = oneOf ('9 ma9 M9 maj9 Maj9 mi9 m9') + elevn = oneOf ('11 ma11 M11 maj11 Maj11 mi m11') + suspended = oneOf ('sus sus2 sus4') + chord_degree = Combine (Optional (chord_accidental) + oneOf ('2 4 5 6 7 9 11 13')) + chord_kind = Optional (seventh | sixth | ninth | elevn | triad, '_') + Optional (suspended) + chord_root = oneOf ('C D E F G A B') + Optional (chord_accidental) + chord_bass = oneOf ('C D E F G A B') + Optional (chord_accidental) # needs a different parse action + chordsym = chord_root + chord_kind + ZeroOrMore (chord_degree) + Optional (Suppress ('/') + chord_bass) + chord_sym = chordsym + Optional (Literal ('(') + CharsNotIn (')') + Literal (')')).suppress () + chord_or_text = Suppress ('"') + (chord_sym ^ text_expression) + Suppress ('"') + + volta_nums = Optional ('[').suppress () + Combine (Word (nums) + ZeroOrMore (oneOf (', -') + Word (nums))) + volta_text = Literal ('[').suppress () + Regex (r'"[^"]+"') + volta = volta_nums | volta_text + invisible_barline = oneOf ('[|] []') + dashed_barline = oneOf (': .|') + double_rep = Literal (':') + FollowedBy (':') # otherwise ambiguity with dashed barline + voice_overlay = Combine (OneOrMore ('&')) + bare_volta = FollowedBy (Literal ('[') + Word (nums)) # no barline, but volta follows (volta is parsed in next measure) + bar_left = (oneOf ('[|: |: [: :') + Optional (volta)) | Optional ('|').suppress () + volta | oneOf ('| [|') + bars = ZeroOrMore (':') + ZeroOrMore ('[') + OneOrMore (oneOf ('| ]')) + bar_right = Optional (decorations) + (invisible_barline | double_rep | Combine (bars) | dashed_barline | voice_overlay | bare_volta) + + errors = ~bar_right + Optional (Word (' \n')) + CharsNotIn (':&|', exact=1) + linebreak = Literal ('$') | ~decorations + Literal ('!') # no need for I:linebreak !!! + element = inline_field | broken | staff_decos | stem | chord_or_text | grace_notes | tuplet_start | linebreak | errors + measure = Group (ZeroOrMore (inline_field) + Optional (bar_left) + ZeroOrMore (element) + bar_right + Optional (linebreak)) + noBarMeasure = Group (ZeroOrMore (inline_field) + Optional (bar_left) + OneOrMore (element) + Optional (linebreak)) + abc_voice = ZeroOrMore (measure) + Optional (noBarMeasure | Group (bar_left)) + ZeroOrMore (inline_field).suppress () + StringEnd () + + #---------------------------------------- + # ABC lyric lines (white space sensitive) + #---------------------------------------- + + skip_note = oneOf ('* - ~') + extend_note = Literal ('_') + measure_end = Literal ('|') + syl_chars = CharsNotIn ('*~-_| \t\n') + white = Word (' \t') + syllable = Combine (Optional ('~') + syl_chars + ZeroOrMore (Literal ('~') + syl_chars)) + Optional ('-') + lyr_elem = (syllable | skip_note | extend_note | measure_end) + Optional (white).suppress () + lyr_head = (Literal ('w:') + Optional (white)).suppress () + lyr_line = Group (lyr_head + ZeroOrMore (lyr_elem) + LineEnd ().suppress ()) + + #---------------------------------------------------------------- + # Parse actions to convert all relevant results into an abstract + # syntax tree where all tree nodes are instances of pObj + #---------------------------------------------------------------- + + ifield.setParseAction (lambda t: pObj ('field', t)) + grand_staff.setParseAction (lambda t: pObj ('grand', t, 1)) # 1 = keep ordered list of results + brace_gr.setParseAction (lambda t: pObj ('bracegr', t, 1)) + bracket_gr.setParseAction (lambda t: pObj ('bracketgr', t, 1)) + voice_gr.setParseAction (lambda t: pObj ('voicegr', t, 1)) + voiceId.setParseAction (lambda t: pObj ('vid', t, 1)) + abc_scoredef.setParseAction (lambda t: pObj ('score', t, 1)) + note_length.setParseAction (lambda t: pObj ('dur', (t[0], (t[2] << len (t[1])) >> 1))) + chordsym.setParseAction (lambda t: pObj ('chordsym', t)) + chord_root.setParseAction (lambda t: pObj ('root', t)) + chord_kind.setParseAction (lambda t: pObj ('kind', t)) + chord_degree.setParseAction (lambda t: pObj ('degree', t)) + chord_bass.setParseAction (lambda t: pObj ('bass', t)) + text_expression.setParseAction (lambda t: pObj ('text', t)) + inline_field.setParseAction (lambda t: pObj ('inline', t)) + grace_notes.setParseAction (doGrace) # (lambda t: pObj ('grace', t)) + acciaccatura.setParseAction (lambda t: pObj ('accia', t)) + note.setParseAction (noteActn) + chord_note.setParseAction (noteActn) + rest.setParseAction (restActn) + decorations.setParseAction (lambda t: pObj ('deco', t)) + slur_ends.setParseAction (lambda t: pObj ('slurs', t)) + chord.setParseAction (lambda t: pObj ('chord', t)) + tie.setParseAction (lambda t: pObj ('tie', t)) + pitch.setParseAction (lambda t: pObj ('pitch', t)) + bare_volta.setParseAction (lambda t: ['|']) # return barline that user forgot + dashed_barline.setParseAction (lambda t: ['.|']) + bar_right.setParseAction (lambda t: pObj ('rbar', t)) + bar_left.setParseAction (lambda t: pObj ('lbar', t)) + broken.setParseAction (lambda t: pObj ('broken', t)) + tuplet_start.setParseAction (lambda t: pObj ('tup', t)) + linebreak.setParseAction (lambda t: pObj ('linebrk', t)) + measure.setParseAction (doMaat) + noBarMeasure.setParseAction (doMaat) + syllable.setParseAction (lambda t: pObj ('syl', t)) + skip_note.setParseAction (lambda t: pObj ('skip', t)) + extend_note.setParseAction (lambda t: pObj ('ext', t)) + measure_end.setParseAction (lambda t: pObj ('sbar', t)) + b1.setParseAction (errorWarn) + errors.setParseAction (errorWarn) + lyr_block = OneOrMore (lyr_line).leaveWhitespace () # after leaveWhiteSpace no more parse actions can be set!! + + return abc_header, abc_voice, lyr_block, abc_scoredef + +class pObj (object): # every relevant parse result is converted into a pObj + def __init__ (s, name, t, seq=0): # t = list of nested parse results + s.name = name # name uniqueliy identifies this pObj + rest = [] # collect parse results that are not a pObj + attrs = {} # new attributes + for x in t: # nested pObj's become attributes of this pObj + if type (x) == pObj: + attrs [x.name] = attrs.get (x.name, []) + [x] + else: + rest.append (x) # collect non-pObj's (mostly literals) + for name, xs in attrs.items (): + if len (xs) == 1: xs = xs[0] # only list if more then one pObj + setattr (s, name, xs) # create the new attributes + s.t = rest # all nested non-pObj's (mostly literals) + s.objs = seq and t or [] # for nested ordered (lyric) pObj's + + def __repr__ (s): # make a nice string representation of a pObj + r = [] + for nm in dir (s): + if nm.startswith ('_'): continue # skip build in attributes + elif nm == 'name': continue # redundant + else: + x = getattr (s, nm) + if not x: continue # s.t may be empty (list of non-pObj's) + if type (x) == types.ListType: r.extend (x) + else: r.append (x) + xs = [] + for x in r: # recursively call __repr__ and convert all strings to latin-1 + if isinstance (x, types.StringTypes): + try: xs.append (x.encode ('latin-1')) + except: xs.append (repr (x)) # string -> no recursion + else: xs.append (repr (x)) # pObj -> recursive call + return '(' + s.name + ' ' +','.join (xs) + ')' + +global prevloc # global to remember previous match position of a note/rest +prevloc = 0 +def detectBeamBreak (line, loc, t): + global prevloc # location in string 'line' of previous note match + xs = line[prevloc:loc+1] # string between previous and current note match + xs = xs.lstrip () # first note match starts on a space! + prevloc = loc # location in string 'line' of current note match + b = pObj ('bbrk', [' ' in xs]) # space somewhere between two notes -> beambreak + t.insert (0, b) # insert beambreak as a nested parse result + +def noteActn (line, loc, t): # detect beambreak between previous and current note/rest + if 'y' in t[0].t: return [] # discard spacer + detectBeamBreak (line, loc, t) # adds beambreak to parse result t as side effect + return pObj ('note', t) + +def restActn (line, loc, t): # detect beambreak between previous and current note/rest + detectBeamBreak (line, loc, t) # adds beambreak to parse result t as side effect + return pObj ('rest', t) + +def errorWarn (line, loc, t): # warning for misplaced symbols and skip them + info ('**misplaced symbol: %s' % t[0], warn=0) + lineCopy = line [:] + if loc > 40: + lineCopy = line [loc - 40: loc + 40] + loc = 40 + info (lineCopy.replace ('\n', ' '), warn=0) + info (loc * '-' + '^', warn=0) + return [] + +#------------------------------------------------------------- +# transformations of a measure (called by parse action doMaat) +#------------------------------------------------------------- + +def simplify (a, b): # divide a and b by their greatest common divisor + x, y = a, b + while b: a, b = b, a % b + return x / a, y / a + +def doBroken (prev, brk, x): + if not prev: info ('error in broken rhythm: %s' % x); return # no changes + nom1, den1 = prev.dur.t # duration of first note/chord + nom2, den2 = x.dur.t # duration of second note/chord + if brk == '>': + nom1, den1 = simplify (3 * nom1, 2 * den1) + nom2, den2 = simplify (1 * nom2, 2 * den2) + elif brk == '<': + nom1, den1 = simplify (1 * nom1, 2 * den1) + nom2, den2 = simplify (3 * nom2, 2 * den2) + elif brk == '>>': + nom1, den1 = simplify (7 * nom1, 4 * den1) + nom2, den2 = simplify (1 * nom2, 4 * den2) + elif brk == '<<': + nom1, den1 = simplify (1 * nom1, 4 * den1) + nom2, den2 = simplify (7 * nom2, 4 * den2) + else: return # give up + prev.dur.t = nom1, den1 # change duration of previous note/chord + x.dur.t = nom2, den2 # and current note/chord + +def convertBroken (t): # convert broken rhythms to normal note durations + prev = None # the last note/chord before the broken symbol + brk = '' # the broken symbol + remove = [] # indexes to broken symbols (to be deleted) in measure + for i, x in enumerate (t): # scan all elements in measure + if x.name == 'note' or x.name == 'chord' or x.name == 'rest': + if brk: # a broken symbol was encountered before + doBroken (prev, brk, x) # change duration previous note/chord/rest and current one + brk = '' + else: + prev = x # remember the last note/chord/rest + elif x.name == 'broken': + brk = x.t[0] # remember the broken symbol (=string) + remove.insert (0, i) # and its index, highest index first + for i in remove: del t[i] # delete broken symbols from high to low + +def convertChord (t): # convert chord to sequence of notes in musicXml-style + ins = [] + for i, x in enumerate (t): + if x.name == 'chord': + if hasattr (x, 'rest') and not hasattr (x, 'note'): # chords containing only rests + if type (x.rest) == types.ListType: x.rest = x.rest[0] # more rests == one rest + ins.insert (0, (i, [x.rest])) # just output a single rest, no chord + continue + num1, den1 = x.dur.t # chord duration + tie = getattr (x, 'tie', None) # chord tie + slurs = getattr (x, 'slurs', []) # slur endings + deco = getattr (x, 'deco', []) # chord decorations + if type (x.note) != types.ListType: x.note = [x.note] # when chord has only one note ... + for j, nt in enumerate (x.note): # all notes of the chord + num2, den2 = nt.dur.t # note duration * chord duration + nt.dur.t = simplify (num1 * num2, den1 * den2) + if tie: nt.tie = tie # tie on all chord notes + if j == 0 and deco: nt.deco = deco # decorations only on first chord note + if j == 0 and slurs: nt.slurs = slurs # slur endings only on first chord note + if j > 0: nt.chord = pObj ('chord', [1]) # label all but first as chord notes + else: # remember all pitches of the chord in the first note + pitches = [n.pitch for n in x.note] # to implement conversion of erroneous ties to slurs + nt.pitches = pObj ('pitches', pitches) + ins.insert (0, (i, x.note)) # high index first + for i, notes in ins: # insert from high to low + for nt in reversed (notes): + t.insert (i+1, nt) # insert chord notes after chord + del t[i] # remove chord itself + +def doMaat (t): # t is a Group() result -> the measure is in t[0] + convertBroken (t[0]) # remove all broken rhythms and convert to normal durations + convertChord (t[0]) # replace chords by note sequences in musicXML style + +def doGrace (t): # t is a Group() result -> the grace sequence is in t[0] + convertChord (t[0]) # a grace sequence may have chords + for nt in t[0]: # flag all notes within the grace sequence + if nt.name == 'note': nt.grace = 1 # set grace attribute + return t[0] # ungroup the parse result +#-------------------- +# musicXML generation +#---------------------------------- + +def compChordTab (): # avoid some typing work: returns mapping constant {ABC chordsyms -> musicXML kind} + maj, min, aug, dim, dom, ch7, ch6, ch9, ch11, hd = 'major minor augmented diminished dominant -seventh -sixth -ninth -11th half-diminished'.split () + triad = zip ('ma Maj maj M mi min m aug dim o + -'.split (), [maj, maj, maj, maj, min, min, min, aug, dim, dim, aug, min]) + seventh = zip ('7 ma7 Maj7 M7 maj7 mi7 m7 dim7 o7 -7 aug7 +7 m7b5 mi7b5'.split (), + [dom, maj+ch7, maj+ch7, maj+ch7, maj+ch7, min+ch7, min+ch7, dim+ch7, dim+ch7, min+ch7, aug+ch7, aug+ch7, hd, hd]) + sixth = zip ('6 ma6 M6 mi6 m6'.split (), [maj+ch6, maj+ch6, maj+ch6, min+ch6, min+ch6]) + ninth = zip ('9 ma9 M9 maj9 Maj9 mi9 m9'.split (), [dom+ch9, maj+ch9, maj+ch9, maj+ch9, maj+ch9, min+ch9, min+ch9]) + elevn = zip ('11 ma11 M11 maj11 Maj11 mi11 m11'.split (), [dom+ch11, maj+ch11, maj+ch11, maj+ch11, maj+ch11, min+ch11, min+ch11]) + return dict (triad + seventh + sixth + ninth + elevn) + +def addElem (parent, child, level): + indent = 2 + chldrn = parent.getchildren () + if chldrn: + chldrn[-1].tail += indent * ' ' + else: + parent.text = '\n' + level * indent * ' ' + parent.append (child) + child.tail = '\n' + (level-1) * indent * ' ' + +def addElemT (parent, tag, text, level): + e = E.Element (tag) + e.text = text + addElem (parent, e, level) + +def mkTmod (tmnum, tmden, lev): + tmod = E.Element ('time-modification') + addElemT (tmod, 'actual-notes', str (tmnum), lev + 1) + addElemT (tmod, 'normal-notes', str (tmden), lev + 1) + return tmod + +def addDirection (parent, elem, lev, gstaff, subelms=[], placement='below', cue_on=0): + dir = E.Element ('direction', placement=placement) + addElem (parent, dir, lev) + typ = E.Element ('direction-type') + addElem (dir, typ, lev + 1) + addElem (typ, elem, lev + 2) + for subel in subelms: addElem (elem, subel, lev + 3) + if cue_on: addElem (dir, E.Element ('level', size='cue'), lev + 1) + if gstaff: addElemT (dir, 'staff', str (gstaff), lev + 1) + return dir + +def removeElems (root_elem, parent_str, elem_str): + for p in root_elem.findall (parent_str): + e = p.find (elem_str) + if e != None: p.remove (e) + +def alignLyr (vce, lyrs): + empty_el = pObj ('leeg', '*') + for k, lyr in enumerate (lyrs): # lyr = one full line of lyrics + i = 0 # syl counter + for msre in vce: # reiterate the voice block for each lyrics line + for elem in msre: + if elem.name == 'note' and not (hasattr (elem, 'chord') or hasattr (elem, 'grace')): + if i >= len (lyr): lr = empty_el + else: lr = lyr [i] + elem.objs.append (lr) + if lr.name != 'sbar': i += 1 + if i < len (lyr) and lyr[i].name == 'sbar': i += 1 + return vce + +slur_move = re.compile (r'(?<![!+])([}><][<>]?)(\)+)') # (?<!...) means: not preceeded by ... +mm_rest = re.compile (r'([XZ])(\d+)') +bar_space = re.compile (r'([:|][ |\[\]]+[:|])') # barlines with spaces +def fixSlurs (x): # repair slurs when after broken sign or grace-close + def f (mo): # replace a multi-measure rest by single measure rests + n = int (mo.group (2)) + return (n * (mo.group (1) + '|')) [:-1] + def g (mo): # squash spaces in barline expressions + return mo.group (1).replace (' ','') + x = mm_rest.sub (f, x) + x = bar_space.sub (g, x) + return slur_move.sub (r'\2\1', x) + +def splitHeaderVoices (abctext): + r1 = re.compile (r'%.*$') # comments + r2 = re.compile (r'^[A-Z]:.*$') # information field + r3 = re.compile (r'^%%(?=[^%])') # directive: ^%% folowed by not a % + xs, nx = [], 0 + for x in abctext.splitlines (): + x = x.strip () + if not x and nx == 1: break # end of tune + x = r3.sub ('I:', x) # replace %% -> I: + x2 = r1.sub ('', x) # remove comment + while x2.endswith ('*'): x2 = x2[:-1] # remove old syntax for right adjusting + if not x2: continue # empty line + if x2[:2] == 'W:': continue # skip W: lyrics + if x2[:2] == 'w:' and xs[-1][-1] == '\\': + xs[-1] = xs[-1][:-1] # ignore line continuation before lyrics line + ro = r2.match (x2) + if ro: # field -> inline_field, escape all ']' + if x2[-1] == '\\': x2 = x2[:-1] # ignore continuation after field line + x2 = '[' + x2.replace (']',r'\]') + ']' + if x2[:2] == '+:': # new style continuation + xs[-1] += x2[2:] + elif xs and xs[-1][-1] == '\\': # old style continuation + xs[-1] = xs[-1][:-1] + x2 + else: # skip lines (except I:) until first X: + if x.startswith ('X:'): + if nx == 1: break # second tune starts without an empty line !! + nx = 1 # start of first tune + if nx == 1 or x.startswith ('I:'): + xs.append (x2) + if xs and xs[-1][-1] == '\\': # nothing left to continue with, remove last continuation + xs[-1] = xs[-1][:-1] + + r1 = re.compile (r'\[[A-Z]:(\\.|[^]\\])*\]') # inline field with escaped ']' + r2 = re.compile (r'\[K:') # start of K: field + r3 = re.compile (r'\[V:|\[I:MIDI') # start of V: field or midi field + fields, voices, b = [], [], 0 + for i, x in enumerate (xs): + n = len (r1.sub ('', x)) # remove all inline fields + if n > 0: b = 1; break # real abc present -> end of header + if r2.search (x): # start of K: field + fields.append (x) + i += 1; b = 1 + break # first K: field -> end of header + if r3.search (x): # start of V: field + voices.append (x) + else: + fields.append (x) + if b: voices += xs[i:] + else: voices += [] # tune has only header fields + header = '\n'.join (fields) + abctext = '\n'.join (voices) + + xs = abctext.split ('[V:') + if len (xs) == 1: abctext = '[V:1]' + abctext # abc has no voice defs at all + elif r1.sub ('', xs[0]).strip (): # remove inline fields from starting text, if any + abctext = '[V:1]' + abctext # abc with voices has no V: at start + + r1 = re.compile (r'\[V:\s*(\S*)[ \]]') # get voice id from V: field (skip spaces betwee V: and ID) + vmap = {} # {voice id -> [voice abc string]} + vorder = {} # mark document order of voices + xs = re.split (r'(\[V:[^]]*\])', abctext) # split on every V-field (V-fields included in split result list) + if len (xs) == 1: raise (Exception ('bugs ...')) + else: + header += xs[0] # xs[0] = text between K: and first V:, normally empty, but we put it in the header + i = 1 + while i < len (xs): # xs = ['', V-field, voice abc, V-field, voice abc, ...] + vce, abc = xs[i:i+2] + id = r1.search (vce).group (1) # get voice ID from V-field + vmap[id] = vmap.get (id, []) + [vce, abc] # collect abc-text for each voice id (include V-fields) + if id not in vorder: vorder [id] = i # store document order of first occurrence of voice id + i += 2 + voices = [] + ixs = sorted ([(i, id) for id, i in vorder.items ()]) # restore document order of voices + for i, id in ixs: + voice = ''.join (vmap [id]) # all abc of one voice + xs = re.split (r'((?:\nw:[^\n]*)+)', voice) # split voice into voice-lyrics blocks + if len (xs) == 1: # no lyrics + voice = fixSlurs (xs[0]) # put slurs right after the notes + vce_lyr = [[voice, '']] + else: + if xs[-1].strip () != '': xs.append ('w:') # last block had no lyrics + vce_lyr = [] # [[voice, lyrics],[],...] list of voice-lyrics blocks + for k in range (0, len (xs) - 1, 2): + voice, lyrics = xs [k:k+2] + voice = fixSlurs (voice) # put slurs right after the notes + vce_lyr.append ((voice, lyrics)) + voices.append ((id, vce_lyr)) + return header, voices + +def mergeMeasure (m1, m2, slur_offset, voice_offset, is_grand=0): + slurs = m2.findall ('note/notations/slur') + for slr in slurs: + slrnum = int (slr.get ('number')) + slur_offset + slr.set ('number', str (slrnum)) # make unique slurnums in m2 + vs = m2.findall ('note/voice') # set all voice number elements in m2 + for v in vs: v.text = str (voice_offset + int (v.text)) + ls = m1.findall ('note/lyric') # all lyric elements in m1 + lnum_max = max ([int (l.get ('number')) for l in ls] + [0]) # highest lyric number in m1 + ls = m2.findall ('note/lyric') # update lyric elements in m2 + for el in ls: + n = int (el.get ('number')) + el.set ('number', str (n + lnum_max)) + ns = m1.findall ('note') # determine the total duration of m1, subtract all backups + dur1 = sum (int (n.find ('duration').text) for n in ns + if n.find ('grace') == None and n.find ('chord') == None) + dur1 -= sum (int (b.text) for b in m1.findall ('backup/duration')) + nns, es = 0, [] # nns = number of real notes in m2 + for e in m2.getchildren (): # scan all elements of m2 + if e.tag == 'attributes': + if not is_grand: continue # no attribute merging for normal voices + else: nns += 1 # but we do merge (clef) attributes for a grand staff + if e.tag == 'print': continue + if e.tag == 'note' and (mxm.gmwr or e.find ('rest') == None): nns += 1 + es.append (e) # buffer elements to be merged + if nns > 0: # only merge if m2 contains any real notes + if dur1 > 0: # only insert backup if duration of m1 > 0 + b = E.Element ('backup') + addElem (m1, b, level=3) + addElemT (b, 'duration', str (dur1), level=4) + for e in es: addElem (m1, e, level=3) # merge buffered elements of m2 + +def mergePartList (parts, is_grand=0): # merge parts, make grand staff when is_grand true + + def delAttrs (part): # for the time being we only keep clef attributes + xs = [(m, e) for m in part.findall ('measure') for e in m.findall ('attributes')] + for m, e in xs: + for c in e.getchildren (): + if c.tag == 'clef': continue # keep clef attribute + e.remove (c) # delete all other attrinutes for higher staff numbers + if len (e.getchildren ()) == 0: m.remove (e) # remove empty attributes element + + p1 = parts[0] + for p2 in parts[1:]: + if is_grand: delAttrs (p2) # delete all attributes except clef + for i in range (len (p1) + 1, len (p2) + 1): # second part longer than first one + maat = E.Element ('measure', number = str(i)) # append empty measures + addElem (p1, maat, 2) + slurs = p1.findall ('measure/note/notations/slur') # find highest slur num in first part + slur_max = max ([int (slr.get ('number')) for slr in slurs] + [0]) + vs = p1.findall ('measure/note/voice') # all voice number elements in first part + vnum_max = max ([int (v.text) for v in vs] + [0]) # highest voice number in first part + for im, m2 in enumerate (p2.findall ('measure')): # merge all measures of p2 into p1 + mergeMeasure (p1[im], m2, slur_max, vnum_max, is_grand) # may change slur numbers in p1 + return p1 + +def mergeParts (parts, vids, staves, is_grand=0): + if not staves: return parts, vids # no voice mapping + partsnew, vidsnew = [], [] + for voice_ids in staves: + pixs = [] + for vid in voice_ids: + if vid in vids: pixs.append (vids.index (vid)) + else: info ('score partname %s does not exist' % vid) + if pixs: + xparts = [parts[pix] for pix in pixs] + if len (xparts) > 1: mergedpart = mergePartList (xparts, is_grand) + else: mergedpart = xparts [0] + partsnew.append (mergedpart) + vidsnew.append (vids [pixs[0]]) + return partsnew, vidsnew + +def mergePartMeasure (part, msre, ovrlaynum): # merge msre into last measure of part, only for overlays + slurs = part.findall ('measure/note/notations/slur') # find highest slur num in part + slur_max = max ([int (slr.get ('number')) for slr in slurs] + [0]) + last_msre = part.getchildren ()[-1] # last measure in part + mergeMeasure (last_msre, msre, slur_max, ovrlaynum) # voice offset = s.overlayVNum + +def setFristVoiceNameFromGroup (vids, vdefs): # vids = [vid], vdef = {vid -> (name, subname, voicedef)} + vids = [v for v in vids if v in vdefs] # only consider defined voices + if not vids: return vdefs + vid0 = vids [0] # first vid of the group + _, _, vdef0 = vdefs [vid0] # keep de voice definition (vdef0) when renaming vid0 + for vid in vids: + nm, snm, vdef = vdefs [vid] + if nm: # first non empty name encountered will become + vdefs [vid0] = nm, snm, vdef0 # name of merged group == name of first voice in group (vid0) + break + return vdefs + +def mkGrand (p, vdefs): # transform parse subtree into list needed for s.grands + xs = [] + for i, x in enumerate (p.objs): # changing p.objs [i] alters the tree. changing x has no effect on the tree. + if type (x) == pObj: + us = mkGrand (x, vdefs) # first get transformation results of current pObj + if x.name == 'grand': # x.objs contains ordered list of nested parse results within x + vids = [y.objs[0] for y in x.objs[1:]] # the voice ids in the grand staff + nms = [vdefs [u][0] for u in vids if u in vdefs] # the names of those voices + accept = sum ([1 for nm in nms if nm]) == 1 # accept as grand staff when only one of the voices has a name + if accept or us[0] == '{*': + xs.append (us[1:]) # append voice ids as a list (discard first item '{' or '{*') + vdefs = setFristVoiceNameFromGroup (vids, vdefs) + p.objs [i] = x.objs[1] # replace voices by first one in the grand group (this modifies the parse tree) + else: + xs.extend (us[1:]) # extend current result with all voice ids of rejected grand staff + else: xs.extend (us) # extend current result with transformed pObj + else: xs.append (p.t[0]) # append the non pObj (== voice id string) + return xs + +def mkStaves (p, vdefs): # transform parse tree into list needed for s.staves + xs = [] + for i, x in enumerate (p.objs): # structure and comments identical to mkGrand + if type (x) == pObj: + us = mkStaves (x, vdefs) + if x.name == 'voicegr': + xs.append (us) + vids = [y.objs[0] for y in x.objs] + vdefs = setFristVoiceNameFromGroup (vids, vdefs) + p.objs [i] = x.objs[0] + else: + xs.extend (us) + else: + if p.t[0] not in '{*': xs.append (p.t[0]) + return xs + +def mkGroups (p): # transform parse tree into list needed for s.groups + xs = [] + for x in p.objs: + if type (x) == pObj: + if x.name == 'vid': xs.extend (mkGroups (x)) + elif x.name == 'bracketgr': xs.extend (['['] + mkGroups (x) + [']']) + elif x.name == 'bracegr': xs.extend (['{'] + mkGroups (x) + ['}']) + else: xs.extend (mkGroups (x) + ['}']) # x.name == 'grand' == rejected grand staff + else: + xs.append (p.t[0]) + return xs + +class MusicXml: + typeMap = {1:'long', 2:'breve', 4:'whole', 8:'half', 16:'quarter', 32:'eighth', 64:'16th', 128:'32nd', 256:'64th'} + dynaMap = {'p':1,'pp':1,'ppp':1,'f':1,'ff':1,'fff':1,'mp':1,'mf':1,'sfz':1} + wedgeMap = {'>(':1, '>)':1, '<(':1,'<)':1,'crescendo(':1,'crescendo)':1,'diminuendo(':1,'diminuendo)':1} + artMap = {'.':'staccato','>':'accent','accent':'accent','wedge':'staccatissimo','tenuto':'tenuto'} + ornMap = {'trill':'trill-mark','T':'trill-mark','turn':'turn','uppermordent':'inverted-mordent','lowermordent':'mordent', + 'pralltriller':'inverted-mordent','mordent':'mordent','turn':'turn','invertedturn':'inverted-turn'} + tecMap = {'upbow':'up-bow', 'downbow':'down-bow'} + capoMap = {'fine':('Fine','fine','yes'), 'D.S.':('D.S.','dalsegno','segno'), 'D.C.':('D.C.','dacapo','yes'),'dacapo':('D.C.','dacapo','yes'), + 'dacoda':('To Coda','tocoda','coda'), 'coda':('coda','coda','coda'), 'segno':('segno','segno','segno')} + sharpness = ['Fb', 'Cb','Gb','Db','Ab','Eb','Bb','F','C','G','D','A', 'E', 'B', 'F#','C#','G#','D#','A#','E#','B#'] + offTab = {'maj':8, 'm':11, 'min':11, 'mix':9, 'dor':10, 'phr':12, 'lyd':7, 'loc':13} + modTab = {'maj':'major', 'm':'minor', 'min':'minor', 'mix':'mixolydian', 'dor':'dorian', 'phr':'phrygian', 'lyd':'lydian', 'loc':'locrian'} + clefMap = { 'alto1':('C','1'), 'alto2':('C','2'), 'alto':('C','3'), 'alto4':('C','4'), 'tenor':('C','4'), + 'bass3':('F','3'), 'bass':('F','4'), 'treble':('G','2'), 'perc':('percussion',''), 'none':('','')} + clefLineMap = {'B':'treble', 'G':'alto1', 'E':'alto2', 'C':'alto', 'A':'tenor', 'F':'bass3', 'D':'bass'} + alterTab = {'=':'0', '_':'-1', '__':'-2', '^':'1', '^^':'2'} + accTab = {'=':'natural', '_':'flat', '__':'flat-flat', '^':'sharp', '^^':'sharp-sharp'} + chordTab = compChordTab () + uSyms = {'~':'roll', 'H':'fermata','L':'>','M':'lowermordent','O':'coda', + 'P':'uppermordent','S':'segno','T':'trill','u':'upbow','v':'downbow'} + pageFmtDef = [1.764,297,210,10,10,10,10] # the MuseScore page formatting defaults for A4 + creditTab = {'O':'origin', 'A':'area', 'Z':'transcription', 'N':'notes', 'G':'group', 'H':'history', 'R':'rhythm', + 'B':'book', 'D':'discography', 'F':'fileurl', 'S':'source'} + + def __init__ (s): + s.pageFmtCmd = [] # set by command line option -p + s.gmwr = 0 # set by command line option -r + s.reset () + def reset (s): + s.divisions = 120 # xml duration of 1/4 note + s.ties = {} # {abc pitch tuple -> alteration} for all open ties + s.slurstack = [] # stack of open slur numbers + s.slurbeg = 0 # number of slurs to start (when slurs are detected at element-level) + s.tmnum = 0 # time modification, numerator + s.tmden = 0 # time modification, denominator + s.ntup = 0 # number of tuplet notes remaining + s.tupnts = [] # all tuplet modifiers with corresp. durations: [(duration, modifier), ...] + s.irrtup = 0 # 1 if an irregular tuplet + s.ntype = '' # the normal-type of a tuplet (== duration type of a normal tuplet note) + s.unitL = (1, 8) # default unit length + s.unitLcur = (1, 8) # unit length of current voice + s.keyAlts = {} # alterations implied by key + s.msreAlts = {} # temporarily alterations + s.curVolta = '' # open volta bracket + s.slurstack = [] # stack of open slur numbers + s.title = '' # title of music + s.creator = {} # {creator-type -> creator string} + s.credits = {} # {credit-type -> string} + s.lyrdash = {} # {lyric number -> 1 if dash between syllables} + s.usrSyms = s.uSyms # user defined symbols + s.prevNote = None # xml element of previous beamed note to correct beams (start, continue) + s.grcbbrk = False # remember any bbrk in a grace sequence + s.linebrk = 0 # 1 if next measure should start with a line break + s.bardecos = [] # barline decorations (coda, segno) that go into the next measure (MuseScore deficiency!) + s.nextdecos = [] # decorations for the next note + s.prevmsre = None # the previous measure + s.supports_tag = 0 # issue supports-tag in xml file when abc uses explicit linebreaks + s.staveDefs = [] # collected %%staves or %%score instructions from score + s.staves = [] # staves = [[voice names to be merged into one stave]] + s.groups = [] # list of merged part names with interspersed {[ and }] + s.grands = [] # [[vid1, vid2, ..], ...] voiceIds to be merged in a grand staff + s.gStaffNums = {} # map each voice id in a grand staff to a staff number + s.gNstaves = {} # map each voice id in a grand staff to total number of staves + s.pageFmtAbc = [] # formatting from abc directives + s.mdur = (4,4) # duration of one measure + s.gtrans = 0 # octave transposition (by clef) + s.midprg = ['', ''] # MIDI channel nr, program nr for the current part + s.vid = '' # abc voice id for the current part + s.gcue_on = 0 # insert <cue/> tag in each note + + def mkPitch (s, acc, note, oct, lev): + nUp = note.upper () + octnum = (4 if nUp == note else 5) + int (oct) + s.gtrans + pitch = E.Element ('pitch') + addElemT (pitch, 'step', nUp, lev + 1) + alter = '' + if (note, oct) in s.ties: + tied_alter, _, vnum = s.ties [(note,oct)] # vnum = overlay voice number when tie started + if vnum == s.overlayVnum: alter = tied_alter # tied note in the same overlay -> same alteration + elif acc: + s.msreAlts [(nUp, octnum)] = s.alterTab [acc] + alter = s.alterTab [acc] # explicit notated alteration + elif (nUp, octnum) in s.msreAlts: alter = s.msreAlts [(nUp, octnum)] # temporary alteration + elif nUp in s.keyAlts: alter = s.keyAlts [nUp] # alteration implied by the key + if alter: addElemT (pitch, 'alter', alter, lev + 1) + addElemT (pitch, 'octave', str (octnum), lev + 1) + return pitch, alter + + def mkNote (s, n, lev): + nnum, nden = n.dur.t # abc dutation of note + if nden == 0: nden = 1 # occurs with illegal ABC like: "A2 1". Now interpreted as A2/1 + num, den = simplify (nnum * s.unitLcur[0], nden * s.unitLcur[1]) # normalised with unit length + if den > 64: # limit denominator to 64 + num = int (round (64 * float (num) / den)) # scale note to num/64 + num, den = simplify (max ([num, 1]), 64) # smallest num == 1 + info ('duration too small: rounded to %d/%d' % (num, den)) + if n.name == 'rest' and ('Z' in n.t or 'X' in n.t): + num, den = s.mdur # duration of one measure + dvs = (4 * s.divisions * num) / den # divisions is xml-duration of 1/4 + rdvs = dvs # real duration (will be 0 for chord/grace) + num, den = simplify (num, den * 4) # scale by 1/4 for s.typeMap + ndot = 0 + if num == 3: ndot = 1; den = den / 2 # look for dotted notes + if num == 7: ndot = 2; den = den / 4 + nt = E.Element ('note') + if getattr (n, 'grace', ''): # a grace note (and possibly a chord note) + grace = E.Element ('grace') + if s.acciatura: grace.set ('slash', 'yes'); s.acciatura = 0 + addElem (nt, grace, lev + 1) + dvs = rdvs = 0 # no (real) duration for a grace note + if den <= 16: den = 32 # not longer than 1/8 for a grace note + if s.gcue_on: # insert cue tag + cue = E.Element ('cue') + addElem (nt, cue, lev + 1) + if getattr (n, 'chord', ''): # a chord note + chord = E.Element ('chord') + addElem (nt, chord, lev + 1) + rdvs = 0 # chord notes no real duration + if rdvs and s.ntup >= 0: s.ntup -= 1 # count tuplet notes only on non-chord, non grace notes (rdvs > 0) + if den not in s.typeMap: # take the nearest smaller legal duration + info ('illegal duration %d/%d' % (nnum, nden)) + den = min (x for x in s.typeMap.keys () if x > den) + xmltype = str (s.typeMap [den]) # xml needs the note type in addition to duration + acc, step, oct = '', 'C', '0' # abc-notated pitch elements (accidental, pitch step, octave) + alter = '' # xml alteration + if n.name == 'rest': + if 'x' in n.t or 'X' in n.t: nt.set ('print-object', 'no') + rest = E.Element ('rest') + addElem (nt, rest, lev + 1) + else: + p = n.pitch.t # get pitch elements from parsed tokens + if len (p) == 3: acc, step, oct = p + else: step, oct = p + pitch, alter = s.mkPitch (acc, step, oct, lev + 1) + addElem (nt, pitch, lev + 1) + if s.ntup >= 0: # modify duration for tuplet notes + dvs = dvs * s.tmden / s.tmnum + if dvs: addElemT (nt, 'duration', str (dvs), lev + 1) # skip when dvs == 0, requirement of musicXML + inst = E.Element ('instrument', id='I-'+s.vid) # instrument id for midi + if s.midprg != ['', '']: addElem (nt, inst, lev + 1) # only add when %%midi was present + addElemT (nt, 'voice', '1', lev + 1) # default voice, for merging later + addElemT (nt, 'type', xmltype, lev + 1) # add note type + for i in range (ndot): # add dots + dot = E.Element ('dot') + addElem (nt, dot, lev + 1) + ptup = (step, oct) # pitch tuple without alteration to check for ties + tstop = ptup in s.ties and s.ties[ptup][2] == s.overlayVnum # open tie on this pitch tuple in this overlay + if acc and not tstop: addElemT (nt, 'accidental', s.accTab [acc], lev + 1) # only add accidental if note not tied + tupnotation = '' # start/stop notation element for tuplets + if s.ntup >= 0: # add time modification element for tuplet notes + tmod = mkTmod (s.tmnum, s.tmden, lev + 1) + addElem (nt, tmod, lev + 1) + if s.ntup > 0 and not s.tupnts: tupnotation = 'start' + s.tupnts.append ((rdvs, tmod)) # remember all tuplet modifiers with corresp. durations + if s.ntup == 0: # last tuplet note (and possible chord notes there after) + if rdvs: tupnotation = 'stop' # only insert notation in the real note (rdvs > 0) + s.cmpNormType (rdvs, lev + 1) # compute and/or add normal-type elements (-> s.ntype) + gstaff = s.gStaffNums.get (s.vid, 0) # staff number of the current voice + if gstaff: addElemT (nt, 'staff', str (gstaff), lev + 1) + s.doBeams (n, nt, den, lev + 1) + s.doNotations (n, ptup, alter, tupnotation, tstop, nt, lev + 1) + if n.objs: s.doLyr (n, nt, lev + 1) + return nt + + def cmpNormType (s, rdvs, lev): # compute the normal-type of a tuplet (only needed for Finale) + if rdvs: # the last real tuplet note (chord notes can still follow afterwards with rdvs == 0) + durs = [dur for dur, tmod in s.tupnts if dur > 0] + ndur = sum (durs) / s.tmnum # duration of the normal type + s.irrtup = any ((dur != ndur) for dur in durs) # irregular tuplet + tix = 16 * s.divisions / ndur # index in typeMap of normal-type duration + if tix in s.typeMap: + s.ntype = str (s.typeMap [tix]) # the normal-type + else: s.irrtup = 0 # give up, no normal type possible + if s.irrtup: # only add normal-type for irregular tuplets + for dur, tmod in s.tupnts: # add normal-type to all modifiers + addElemT (tmod, 'normal-type', s.ntype, lev + 1) + s.tupnts = [] # reset the tuplet buffer + + def doNotations (s, n, ptup, alter, tupnotation, tstop, nt, lev): + slurs = getattr (n, 'slurs', 0) # slur ends + pts = getattr (n, 'pitches', []) # all chord notes available in the first note + if pts: # make list of pitches in chord: [(pitch, octave), ..] + if type (pts.pitch) == pObj: pts = [pts.pitch] # chord with one note + else: pts = [tuple (p.t[-2:]) for p in pts.pitch] # normal chord + for pt, (tie_alter, nts, vnum) in s.ties.items (): # scan all open ties and delete illegal ones + if vnum != s.overlayVnum: continue # tie belongs to different overlay + if pts and pt in pts: continue # pitch tuple of tie exists in chord + if getattr (n, 'chord', 0): continue # skip chord notes + if pt == ptup: continue # skip correct single note tie + if getattr (n, 'grace', 0): continue # skip grace notes + info ('tie between different pitches: %s%s converted to slur' % pt) + del s.ties [pt] # remove the note from pending ties + e = [t for t in nts.findall ('tied') if t.get ('type') == 'start'][0] # get the tie start element + e.tag = 'slur' # convert tie into slur + slurnum = len (s.slurstack) + 1 + s.slurstack.append (slurnum) + e.set ('number', str (slurnum)) + if slurs: slurs.t.append (')') # close slur on this note + else: slurs = pObj ('slurs', [')']) + tstart = getattr (n, 'tie', 0) # start a new tie + decos = s.nextdecos # decorations encountered so far + ndeco = getattr (n, 'deco', 0) # possible decorations of notes of a chord + if ndeco: # add decorations, translate used defined symbols + decos += [s.usrSyms.get (d, d).strip ('!+') for d in ndeco.t] + s.nextdecos = [] + if not (tstop or tstart or decos or slurs or s.slurbeg or tupnotation): return nt + nots = E.Element ('notations') # notation element needed + if tupnotation: # add tuplet type + tup = E.Element ('tuplet', type=tupnotation) + if tupnotation == 'start': tup.set ('bracket', 'yes') + addElem (nots, tup, lev + 1) + if tstop: # stop tie + del s.ties[ptup] # remove flag + tie = E.Element ('tied', type='stop') + addElem (nots, tie, lev + 1) + if tstart: # start a tie + s.ties[ptup] = (alter, nots, s.overlayVnum) # remember pitch tuple to stop tie and apply same alteration + tie = E.Element ('tied', type='start') + addElem (nots, tie, lev + 1) + if decos: # look for slurs and decorations + arts = [] # collect articulations + for d in decos: # do all slurs and decos + if d == '(': s.slurbeg += 1; continue # slurs made in while loop at the end + elif d == 'fermata' or d == 'H': + ntn = E.Element ('fermata', type='upright') + elif d == 'arpeggio': + ntn = E.Element ('arpeggiate', number='1') + else: arts.append (d); continue + addElem (nots, ntn, lev + 1) + if arts: # do only note articulations and collect staff annotations in xmldecos + rest = s.doArticulations (nots, arts, lev + 1) + if rest: info ('unhandled note decorations: %s' % rest) + while s.slurbeg > 0: + s.slurbeg -= 1 + slurnum = len (s.slurstack) + 1 + s.slurstack.append (slurnum) + ntn = E.Element ('slur', number='%d' % slurnum, type='start') + addElem (nots, ntn, lev + 1) + if slurs: # these are only slur endings + for d in slurs.t: + if not s.slurstack: break # no more open slurs + slurnum = s.slurstack.pop () + slur = E.Element ('slur', number='%d' % slurnum, type='stop') + addElem (nots, slur, lev + 1) + if nots.getchildren() != []: # only add notations if not empty + addElem (nt, nots, lev) + + def doArticulations (s, nots, arts, lev): + decos = [] + for a in arts: + if a in s.artMap: + art = E.Element ('articulations') + addElem (nots, art, lev) + addElem (art, E.Element (s.artMap[a]), lev + 1) + elif a in s.ornMap: + orn = E.Element ('ornaments') + addElem (nots, orn, lev) + addElem (orn, E.Element (s.ornMap[a]), lev + 1) + elif a in s.tecMap: + tec = E.Element ('technical') + addElem (nots, tec, lev) + addElem (tec, E.Element (s.tecMap[a]), lev + 1) + else: decos.append (a) # return staff annotations + return decos + + def doLyr (s, n, nt, lev): + for i, lyrobj in enumerate (n.objs): + if lyrobj.name != 'syl': continue + dash = len (lyrobj.t) == 2 + if dash: + if i in s.lyrdash: type = 'middle' + else: type = 'begin'; s.lyrdash [i] = 1 + else: + if i in s.lyrdash: type = 'end'; del s.lyrdash [i] + else: type = 'single' + lyrel = E.Element ('lyric', number = str (i + 1)) + addElem (nt, lyrel, lev) + addElemT (lyrel, 'syllabic', type, lev + 1) + addElemT (lyrel, 'text', lyrobj.t[0].replace ('~',' '), lev + 1) + + def doBeams (s, n, nt, den, lev): + if hasattr (n, 'chord') or hasattr (n, 'grace'): + s.grcbbrk = s.grcbbrk or n.bbrk.t[0] # remember if there was any bbrk in or before a grace sequence + return + bbrk = s.grcbbrk or n.bbrk.t[0] or den < 32 + s.grcbbrk = False + if not s.prevNote: pbm = None + else: pbm = s.prevNote.find ('beam') + bm = E.Element ('beam', number='1') + bm.text = 'begin' + if pbm != None: + if bbrk: + if pbm.text == 'begin': + s.prevNote.remove (pbm) + elif pbm.text == 'continue': + pbm.text = 'end' + s.prevNote = None + else: bm.text = 'continue' + if den >= 32 and n.name != 'rest': + addElem (nt, bm, lev) + s.prevNote = nt + + def stopBeams (s): + if not s.prevNote: return + pbm = s.prevNote.find ('beam') + if pbm != None: + if pbm.text == 'begin': + s.prevNote.remove (pbm) + elif pbm.text == 'continue': + pbm.text = 'end' + s.prevNote = None + + def staffDecos (s, decos, maat, lev, bardecos=0): + gstaff = s.gStaffNums.get (s.vid, 0) # staff number of the current voice + for d in decos: + d = s.usrSyms.get (d, d).strip ('!+') # try to replace user defined symbol + if d in s.dynaMap: + dynel = E.Element ('dynamics') + addDirection (maat, dynel, lev, gstaff, [E.Element (d)], 'below', s.gcue_on) + elif d in s.wedgeMap: # wedge + if ')' in d: type = 'stop' + else: type = 'crescendo' if '<' in d or 'crescendo' in d else 'diminuendo' + addDirection (maat, E.Element ('wedge', type=type), lev, gstaff) + elif d in ['coda', 'segno']: + if bardecos: s.bardecos.append (d) # postpone to begin next measure + else: + text, attr, val = s.capoMap [d] + dir = addDirection (maat, E.Element (text), lev, gstaff, placement='above') + sound = E.Element ('sound'); sound.set (attr, val) + addElem (dir, sound, lev + 1) + elif d in s.capoMap: + text, attr, val = s.capoMap [d] + words = E.Element ('words'); words.text = text + dir = addDirection (maat, words, lev, gstaff, placement='above') + sound = E.Element ('sound'); sound.set (attr, val) + addElem (dir, sound, lev + 1) + elif d == '(': s.slurbeg += 1 # start slur on next note + else: s.nextdecos.append (d) # keep annotation for the next note + + def doFields (s, maat, fieldmap, lev): + def doClef (): + clef, gtrans = 0, 0 + clefn = re.search (r'alto1|alto2|alto4|alto|tenor|bass3|bass|treble|perc|none', field) + clefm = re.search (r"(?:^m=| m=|middle=)([A-Ga-g])([,']*)", field) + trans_oct2 = re.search (r'octave=([-+]\d)', field) + trans = re.search (r'(?:^t=| t=|transpose=)(-?[\d]+)', field) + trans_oct = re.search (r'([+-^_])(8|15)', field) + cue_onoff = re.search (r'cue=(on|off)', field) + if clefn: + clef = clefn.group () + if clefm: + note, octstr = clefm.groups () + nUp = note.upper () + octnum = (4 if nUp == note else 5) + (len (octstr) if "'" in octstr else -len (octstr)) + gtrans = (3 if nUp in 'AFD' else 4) - octnum + if clef not in ['perc', 'none']: clef = s.clefLineMap [nUp] + if clef: + s.gtrans = gtrans # only change global tranposition when a clef is really defined + sign, line = s.clefMap [clef] + if not sign: return + c = E.Element ('clef') + gstaff = s.gStaffNums.get (s.vid, 0) # the current staff number + if gstaff: c.set ('number', str (gstaff)) # only add staff number when defined + addElemT (c, 'sign', sign, lev + 2) + if line: addElemT (c, 'line', line, lev + 2) + if trans_oct: + n = trans_oct.group (1) in '-_' and -1 or 1 + if trans_oct.group (2) == '15': n *= 2 # 8 => 1 octave, 15 => 2 octaves + addElemT (c, 'clef-octave-change', str (n), lev + 2) # transpose print out + if trans_oct.group (1) in '+-': s.gtrans += n # also transpose all pitches with one octave + if trans_oct2: + n = int (trans_oct2.group (1)) + s.gtrans += n + atts.append ((7, c)) + if trans != None: # add transposition in semitones + e = E.Element ('transpose') + addElemT (e, 'chromatic', str (trans.group (1)), lev + 3) + atts.append ((9, e)) + if cue_onoff: s.gcue_on = cue_onoff.group (1) == 'on' + atts = [] # collect xml attribute elements [(order-number, xml-element), ..] + for ftype, field in fieldmap.items (): + if not field: # skip empty fields + continue + if ftype == 'Div': # not an abc field, but handled as if + d = E.Element ('divisions') + d.text = field + atts.append ((1, d)) + elif ftype == 'gstaff': # make grand staff + e = E.Element ('staves') + e.text = str (field) + atts.append ((4, e)) + elif ftype == 'M': + if field == 'none': continue + if field == 'C': field = '4/4' + elif field == 'C|': field = '2/2' + t = E.Element ('time') + if '/' not in field: + info ('M:%s not recognized, 4/4 assumed' % field) + field = '4/4' + beats, btype = field.split ('/')[:2] + try: s.mdur = simplify (eval (beats), int (btype)) # measure duration for Z and X rests (eval allows M:2+3/4) + except: + info ('error in M:%s, 4/4 assumed' % field) + s.mdur = (4,4) + beats, btype = '4','4' + addElemT (t, 'beats', beats, lev + 2) + addElemT (t, 'beat-type', btype, lev + 2) + atts.append ((3, t)) + elif ftype == 'K': + accs = ['F','C','G','D','A','E','B'] # == s.sharpness [7:14] + mode = '' + key = re.match (r'\s*([A-G][#b]?)\s*([a-zA-Z]*)', field) + alts = re.search (r'\s((\s?[=^_][A-Ga-g])+)', ' ' + field) # avoid matching middle=G and m=G + if key: + key, mode = key.groups () + mode = mode.lower ()[:3] # only first three chars, no case + if mode not in s.offTab: mode = 'maj' + fifths = s.sharpness.index (key) - s.offTab [mode] + if fifths >= 0: s.keyAlts = dict (zip (accs[:fifths], fifths * ['1'])) + else: s.keyAlts = dict (zip (accs[fifths:], -fifths * ['-1'])) + elif field.startswith ('none') or field == '': # the default key + fifths = 0 + mode = 'maj' + if alts: + alts = re.findall (r'[=^_][A-Ga-g]', alts.group(1)) # list of explicit alterations + alts = [(x[1], s.alterTab [x[0]]) for x in alts] # [step, alter] + for step, alter in alts: # correct permanent alterations for this key + s.keyAlts [step.upper ()] = alter + k = E.Element ('key') + koctave = [] + lowerCaseSteps = [step.upper () for step, alter in alts if step.islower ()] + for step, alter in s.keyAlts.items (): + if alter == '0': # skip neutrals + del s.keyAlts [step.upper ()] # otherwise you get neutral signs on normal notes + continue + addElemT (k, 'key-step', step.upper (), lev + 2) + addElemT (k, 'key-alter', alter, lev + 2) + koctave.append ('5' if step in lowerCaseSteps else '4') + if koctave: # only key signature if not empty + for oct in koctave: + e = E.Element ('key-octave', number=oct) + addElem (k, e, lev + 2) + atts.append ((2, k)) + elif mode: + k = E.Element ('key') + addElemT (k, 'fifths', str (fifths), lev + 2) + addElemT (k, 'mode', s.modTab [mode], lev + 2) + atts.append ((2, k)) + doClef () + elif ftype == 'L': + s.unitLcur = map (int, field.split ('/')) + if len (s.unitLcur) == 1 or s.unitLcur[1] not in s.typeMap: + info ('L:%s is not allowed, 1/8 assumed' % field) + s.unitLcur = 1,8 + elif ftype == 'V': + doClef () + elif ftype == 'I': + xs = s.doField_I (ftype, field) + if xs and len (xs) == 1: # when "%%MIDI transpose" matched insert 'attribute/transpose/chromatic' + e = E.Element ('transpose') + addElemT (e, 'chromatic', xs[0], lev + 2) # xs[0] == signed number string given after transpose + atts.append ((9, e)) + if xs and len (xs) == 2: # repeated occurrence of [I:MIDI] -> instrument change + midchan, midprog = xs + snd = E.Element ('sound') + mi = E.Element ('midi-instrument', id='I-' + s.vid) + addElem (maat, snd, lev) + addElem (snd, mi, lev + 1) + if midchan: addElemT (mi, 'midi-channel', midchan, lev + 2) + if midprog: addElemT (mi, 'midi-program', str (int (midprog) + 1), lev + 2) # compatible with abc2midi + + elif ftype == 'Q': + s.doTempo (maat, field, lev) + elif ftype in 'TCOAZNGHRBDFSU': + info ('**illegal header field in body: %s, content: %s' % (ftype, field)) + else: + info ('unhandled field: %s, content: %s' % (ftype, field)) + + if atts: + att = E.Element ('attributes') # insert sub elements in the order required by musicXML + addElem (maat, att, lev) + for _, att_elem in sorted (atts): # ordering ! + addElem (att, att_elem, lev + 1) + + def doTempo (s, maat, field, lev): + gstaff = s.gStaffNums.get (s.vid, 0) # staff number of the current voice + t = re.search (r'(\d)/(\d\d?)\s*=\s*([.\d]+)|([.\d]+)', field) + if not t: return + try: + if t.group (4): + num, den, upm = 1, s.unitLcur[1] , float (t.group (4)) + else: + num, den, upm = int (t.group (1)), int (t.group (2)), float (t.group (3)) + except: return # float or int conversion failure + if num != 1: info ('in Q: numerator > 1 in %d/%d not supported' % (num, den)) + qpm = 4. * num * upm / den + metro = E.Element ('metronome') + u = E.Element ('beat-unit'); u.text = s.typeMap [4 * den] + pm = E.Element ('per-minute'); pm.text = '%.2f' % upm + dir = addDirection (maat, metro, lev, gstaff, [u, pm], placement='above') + sound = E.Element ('sound'); sound.set ('tempo', '%.2f' % qpm) + addElem (dir, sound, lev + 1) + + def mkBarline (s, maat, loc, lev, style='', dir='', ending=''): + b = E.Element ('barline', location=loc) + if style: + addElemT (b, 'bar-style', style, lev + 1) + if s.curVolta: # first stop a current volta + end = E.Element ('ending', number=s.curVolta, type='stop') + s.curVolta = '' + if loc == 'left': # stop should always go to a right barline + bp = E.Element ('barline', location='right') + addElem (bp, end, lev + 1) + addElem (s.prevmsre, bp, lev) # prevmsre has no right barline! (ending would have stopped there) + else: + addElem (b, end, lev + 1) + if ending: + ending = ending.replace ('-',',') # MusicXML only accepts comma's + endtxt = '' + if ending.startswith ('"'): # ending is a quoted string + endtxt = ending.strip ('"') + ending = '33' # any number that is not likely to occur elsewhere + end = E.Element ('ending', number=ending, type='start') + if endtxt: end.text = endtxt # text appears in score in stead of number attribute + addElem (b, end, lev + 1) + s.curVolta = ending + if dir: + r = E.Element ('repeat', direction=dir) + addElem (b, r, lev + 1) + addElem (maat, b, lev) + + def doChordSym (s, maat, sym, lev): + alterMap = {'#':'1','=':'0','b':'-1'} + rnt = sym.root.t + chord = E.Element ('harmony') + addElem (maat, chord, lev) + root = E.Element ('root') + addElem (chord, root, lev + 1) + addElemT (root, 'root-step', rnt[0], lev + 2) + if len (rnt) == 2: addElemT (root, 'root-alter', alterMap [rnt[1]], lev + 2) + kind = s.chordTab.get (sym.kind.t[0], 'major') + addElemT (chord, 'kind', kind, lev + 1) + degs = getattr (sym, 'degree', '') + if degs: + if type (degs) != types.ListType: degs = [degs] + for deg in degs: + deg = deg.t[0] + if deg[0] == '#': alter = '1'; deg = deg[1:] + elif deg[0] == 'b': alter = '-1'; deg = deg[1:] + else: alter = '0'; deg = deg + degree = E.Element ('degree') + addElem (chord, degree, lev + 1) + addElemT (degree, 'degree-value', deg, lev + 2) + addElemT (degree, 'degree-alter', alter, lev + 2) + addElemT (degree, 'degree-type', 'add', lev + 2) + + def mkMeasure (s, i, t, lev, fieldmap={}): + s.msreAlts = {} + s.ntup = -1 + s.acciatura = 0 # next grace element gets acciatura attribute + overlay = 0 + maat = E.Element ('measure', number = str(i)) + if fieldmap: s.doFields (maat, fieldmap, lev + 1) + if s.linebrk: # there was a line break in the previous measure + e = E.Element ('print') + e.set ('new-system', 'yes') + addElem (maat, e, lev + 1) + s.linebrk = 0 + if s.bardecos: # output coda and segno attached to the previous right barline + s.staffDecos (s.bardecos, maat, lev + 1) + s.bardecos = [] + for it, x in enumerate (t): + if x.name == 'note' or x.name == 'rest': + note = s.mkNote (x, lev + 1) + addElem (maat, note, lev + 1) + elif x.name == 'lbar': + bar = x.t[0] + if bar == '|': pass # skip redundant bar + elif ':' in bar: # forward repeat + volta = x.t[1] if len (x.t) == 2 else '' + s.mkBarline (maat, 'left', lev + 1, style='heavy-light', dir='forward', ending=volta) + else: # bar must be a volta number + s.mkBarline (maat, 'left', lev + 1, ending=bar) + elif x.name == 'rbar': + if hasattr (x, 'deco'): # MuseScore does not support this -> emergency solution + s.staffDecos (x.deco.t, maat, lev + 1, bardecos=1) # coda, segno -> next measure + bar = x.t[0] + if bar == '.|': + s.mkBarline (maat, 'right', lev + 1, style='dotted') + elif ':' in bar: # backward repeat + s.mkBarline (maat, 'right', lev + 1, style='light-heavy', dir='backward') + elif bar == '||': + s.mkBarline (maat, 'right', lev + 1, style='light-light') + elif bar == '[|]' or bar == '[]': + s.mkBarline (maat, 'right', lev + 1, style='none') + elif '[' in bar or ']' in bar: + s.mkBarline (maat, 'right', lev + 1, style='light-heavy') + elif bar[0] == '&': overlay = 1 + elif x.name == 'tup': + if len (x.t) == 3: n, into, nts = x.t + else: n, into, nts = x.t[0], 0, 0 + if into == 0: into = 3 if n in [2,4,8] else 2 + if nts == 0: nts = n + s.tmnum, s.tmden, s.ntup = n, into, nts + elif x.name == 'deco': + s.staffDecos (x.t, maat, lev + 1) # output staff decos, postpone note decos to next note + elif x.name == 'text': + pos, text = x.t[:2] + place = 'above' if pos == '^' else 'below' + words = E.Element ('words') + words.text = text + gstaff = s.gStaffNums.get (s.vid, 0) # staff number of the current voice + addDirection (maat, words, lev + 1, gstaff, placement=place) + elif x.name == 'inline': + fieldtype, fieldval = x.t[:2] + s.doFields (maat, {fieldtype:fieldval}, lev + 1) + elif x.name == 'accia': s.acciatura = 1 + elif x.name == 'linebrk': + s.supports_tag = 1 + if it > 0 and t[it -1].name == 'lbar': # we are at start of measure + e = E.Element ('print') # output linebreak now + e.set ('new-system', 'yes') + addElem (maat, e, lev + 1) + else: + s.linebrk = 1 # output linebreak at start of next measure + elif x.name == 'chordsym': + s.doChordSym (maat, x, lev + 1) + s.stopBeams () + s.prevmsre = maat + return maat, overlay + + def mkPart (s, maten, id, lev, attrs, nstaves): + s.slurstack = [] + s.unitLcur = s.unitL # set the default unit length at begin of each voice + s.curVolta = '' + s.lyrdash = {} + s.linebrk = 0 + s.midprg = ['', ''] # MIDI channel nr, program nr for the current part + s.gcue_on = 0 # reset cue note marker for each new voice + s.gtrans = 0 # reset octave transposition (by clef) + part = E.Element ('part', id=id) + s.overlayVnum = 0 # overlay voice number to relate ties that extend from one overlayed measure to the next + gstaff = s.gStaffNums.get (s.vid, 0) # staff number of the current voice + attrs_cpy = attrs.copy () # don't change attrs itself in next line + if gstaff == 1: attrs_cpy ['gstaff'] = nstaves # make a grand staff + msre, overlay = s.mkMeasure (1, maten[0], lev + 1, attrs_cpy) + addElem (part, msre, lev + 1) + for i, maat in enumerate (maten[1:]): + s.overlayVnum = s.overlayVnum + 1 if overlay else 0 + msre, next_overlay = s.mkMeasure (i+2, maat, lev + 1) + if overlay: mergePartMeasure (part, msre, s.overlayVnum) + else: addElem (part, msre, lev + 1) + overlay = next_overlay + return part + + def mkScorePart (s, id, vids_p, partAttr, lev): + naam, subnm, midprg = partAttr [id] + sp = E.Element ('score-part', id='P'+id) + nm = E.Element ('part-name') + nm.text = naam + addElem (sp, nm, lev + 1) + snm = E.Element ('part-abbreviation') + snm.text = subnm + if subnm: addElem (sp, snm, lev + 1) # only add if subname was given + if s.staves: instr_vids = [vids for vids in s.staves if vids[0] == id][0] + else: instr_vids = [id] + inst = [] + for id in instr_vids: + if id not in partAttr: continue # error in %%score -> instr_vids may have non existing id's + naam, subnm, midprg = partAttr [id] + midchan, midprog = midprg + if not midchan and not midprog: continue # only add if program nr or channel was given + si = E.Element ('score-instrument', id='I-'+id) + addElemT (si, 'instrument-name', naam, lev + 2) + mi = E.Element ('midi-instrument', id='I-'+id) + if midchan: addElemT (mi, 'midi-channel', midchan, lev + 2) + if midprog: addElemT (mi, 'midi-program', str (int (midprog) + 1), lev + 2) # compatible with abc2midi + inst.append ((si, mi)) + for si, mi in inst: addElem (sp, si, lev + 1) + for si, mi in inst: addElem (sp, mi, lev + 1) + return sp, len (inst) + + def mkPartlist (s, vids, partAttr, lev): + def addPartGroup (sym, num): + pg = E.Element ('part-group', number=str (num), type='start') + addElem (partlist, pg, lev + 1) + addElemT (pg, 'group-symbol', sym, lev + 2) + addElemT (pg, 'group-barline', 'yes', lev + 2) + partlist = E.Element ('part-list') + g_num = 0 # xml group number + nInstrs = [] # number of instruments in each part + for g in (s.groups or vids): # brace/bracket or abc_voice_id + if g == '[': g_num += 1; addPartGroup ('bracket', g_num) + elif g == '{': g_num += 1; addPartGroup ('brace', g_num) + elif g in '}]': + pg = E.Element ('part-group', number=str (g_num), type='stop') + addElem (partlist, pg, lev + 1) + g_num -= 1 + else: # g = abc_voice_id + if g not in vids: continue # error in %%score + sp, nInst = s.mkScorePart (g, vids, partAttr, lev + 1) + addElem (partlist, sp, lev + 1) + nInstrs.append (nInst) + return partlist, nInstrs + + def doField_I (s, type, x): + def readPfmt (x, n): # read ABC page formatting constant + if not s.pageFmtAbc: s.pageFmtAbc = s.pageFmtDef # set the default values on first change + ro = re.search (r'[^.\d]*([\d.]+)\s*(cm|in|pt)?', x) # float followed by unit + if ro: + x, unit = ro.groups () # unit == None when not present + u = {'cm':10., 'in':25.4, 'pt':25.4/72} [unit] if unit else 1. + s.pageFmtAbc [n] = float (x) * u # convert ABC values to millimeters + else: info ('error in page format: %s' % x) + + if x.startswith ('score') or x.startswith ('staves'): + s.staveDefs += [x] # collect all voice mappings + elif x.startswith ('staffwidth'): info ('skipped I-field: %s' % x) + elif x.startswith ('staff'): # set new staff number of the current voice + r1 = re.search (r'staff *([+-]?)(\d)', x) + if r1: + sign = r1.group (1) + num = int (r1.group (2)) + gstaff = s.gStaffNums.get (s.vid, 0) # staff number of the current voice + if sign: # relative staff number + num = (sign == '-') and gstaff - num or gstaff + num + else: # absolute abc staff number + try: vabc = s.staves [num - 1][0] # vid of (first voice of) abc-staff num + except: vabc = 0; info ('abc staff %s does not exist' % num) + num = s.gStaffNumsOrg.get (vabc, 0) # xml staff number of abc-staff num + if gstaff and num > 0 and num <= s.gNstaves [s.vid]: + s.gStaffNums [s.vid] = num + else: info ('could not relocate to staff: %s' % r1.group ()) + else: info ('not a valid staff redirection: %s' % x) + elif x.startswith ('scale'): readPfmt (x, 0) + elif x.startswith ('pageheight'): readPfmt (x, 1) + elif x.startswith ('pagewidth'): readPfmt (x, 2) + elif x.startswith ('leftmargin'): readPfmt (x, 3) + elif x.startswith ('rightmargin'): readPfmt (x, 4) + elif x.startswith ('topmargin'): readPfmt (x, 5) + elif x.startswith ('botmargin'): readPfmt (x, 6) + elif x.startswith ('MIDI'): + r1 = re.search (r'program *(\d*) +(\d+)', x) + r2 = re.search (r'channel\D*(\d+)', x) + if r1: ch, prg = r1.groups () # channel nr or '', program nr + if r2: ch, prg = r2.group (1), '' # channel nr only + if r1 or r2: + if s.midprg[1] == '': # no instrument defined yet + s.midprg[1] = prg + if ch: s.midprg[0] = ch + elif ch and s.midprg[0] == '': # no channel defined yet + s.midprg[0] = ch + else: # repeated midi def -> insert instument change + return [ch, prg] + r = re.search (r'transpose[^-\d]*(-?\d+)', x) + if r: return [r.group (1)] + else: info ('skipped I-field: %s' % x) + + def parseStaveDef (s, vdefs): + if not s.staveDefs: return vdefs + for x in s.staveDefs [1:]: info ('%%%%%s dropped, multiple stave mappings not supported' % x) + x = s.staveDefs [0] # only the first %%score is honoured + score = abc_scoredef.parseString (x) [0] + f = lambda x: type (x) == types.UnicodeType and [x] or x + s.staves = map (f, mkStaves (score, vdefs)) + s.grands = map (f, mkGrand (score, vdefs)) + s.groups = mkGroups (score) + vce_groups = [vids for vids in s.staves if len (vids) > 1] # all voice groups + d = {} # for each voice group: map first voice id -> all merged voice ids + for vgr in vce_groups: d [vgr[0]] = vgr + for gstaff in s.grands: # for all grand staves + if len (gstaff) == 1: continue # skip single parts + for v, stf_num in zip (gstaff, range (1, len (gstaff) + 1)): + for vx in d.get (v, [v]): # allocate staff numbers + s.gStaffNums [vx] = stf_num # to all constituant voices + s.gNstaves [vx] = len (gstaff) # also remember total number of staves + s.gStaffNumsOrg = s.gStaffNums.copy () # keep original allocation for abc -> xml staff map + return vdefs + + def voiceNamesAndMaps (s, ps): # get voice names and mappings + vdefs = {} + for vid, vcedef, vce in ps: # vcedef == emtpy of first pObj == voice definition + pname, psubnm = '', '' # part name and abbreviation + if not vcedef: # simple abc without voice definitions + vdefs [vid] = pname, psubnm, '' + else: # abc with voice definitions + if vid != vcedef.t[1]: info ('voice ids unequal: %s (reg-ex) != %s (grammar)' % (vid, vcedef.t[1])) + rn = re.search (r'(?:name|nm)="([^"]*)"', vcedef.t[2]) + if rn: pname = rn.group (1) + rn = re.search (r'(?:subname|snm|sname)="([^"]*)"', vcedef.t[2]) + if rn: psubnm = rn.group (1) + vdefs [vid] = pname, psubnm, vcedef.t[2] + xs = [pObj.t[1] for maat in vce for pObj in maat if pObj.name == 'inline'] # all inline statements in vce + s.staveDefs += [x for x in xs if x.startswith ('score') or x.startswith ('staves')] # filter %%score and %%staves + return vdefs + + def doHeaderField (s, fld, attrmap): + type, value = fld.t[:2] + if not value: # skip empty field + return + if type == 'M': + attrmap [type] = value + elif type == 'L': + try: s.unitL = map (int, fld.t[1].split ('/')) + except: + info ('illegal unit length:%s, 1/8 assumed' % fld.t[1]) + s.unitL = 1,8 + if len (s.unitL) == 1 or s.unitL[1] not in s.typeMap: + info ('L:%s is not allowed, 1/8 assumed' % fld.t[1]) + s.unitL = 1,8 + elif type == 'K': + attrmap[type] = value + elif type == 'T': + if s.title: s.title = s.title + '\n' + value + else: s.title = value + elif type == 'C': + s.creator ['composer'] = s.creator.get ('composer', '') + value + elif type == 'Z': + s.creator ['lyricist'] = s.creator.get ('lyricist', '') + value + elif type == 'U': + sym = fld.t[2].strip ('!+') + s.usrSyms [value] = sym + elif type == 'I': + s.doField_I (type, value) + elif type == 'Q': + attrmap[type] = value + elif type in s.creditTab: s.credits [s.creditTab [type]] = value + else: + info ('skipped header: %s' % fld) + + def mkIdentification (s, score, lev): + if s.title: + addElemT (score, 'movement-title', s.title, lev + 1) + ident = E.Element ('identification') + addElem (score, ident, lev + 1) + if s.creator: + for ctype, cname in s.creator.items (): + c = E.Element ('creator', type=ctype) + c.text = cname + addElem (ident, c, lev + 2) + encoding = E.Element ('encoding') + addElem (ident, encoding, lev + 2) + encoder = E.Element ('encoder') + encoder.text = 'abc2xml version %d' % VERSION + addElem (encoding, encoder, lev + 3) + if s.supports_tag: # avoids interference of auto-flowing and explicit linebreaks + suports = E.Element ('supports', attribute="new-system", element="print", type="yes", value="yes") + addElem (encoding, suports, lev + 3) + encodingDate = E.Element ('encoding-date') + encodingDate.text = str (datetime.date.today ()) + addElem (encoding, encodingDate, lev + 3) + + def mkDefaults (s, score, lev): + if s.pageFmtCmd: s.pageFmtAbc = s.pageFmtCmd + if not s.pageFmtAbc: return # do not output the defaults if none is desired + space, h, w, l, r, t, b = s.pageFmtAbc + mils = 4 * space # staff height in millimeters + scale = 40. / mils # tenth's per millimeter + dflts = E.Element ('defaults') + addElem (score, dflts, lev) + scaling = E.Element ('scaling') + addElem (dflts, scaling, lev + 1) + addElemT (scaling, 'millimeters', '%g' % mils, lev + 2) + addElemT (scaling, 'tenths', '40', lev + 2) + layout = E.Element ('page-layout') + addElem (dflts, layout, lev + 1) + addElemT (layout, 'page-height', '%g' % (h * scale), lev + 2) + addElemT (layout, 'page-width', '%g' % (w * scale), lev + 2) + margins = E.Element ('page-margins', type='both') + addElem (layout, margins, lev + 2) + addElemT (margins, 'left-margin', '%g' % (l * scale), lev + 3) + addElemT (margins, 'right-margin', '%g' % (r * scale), lev + 3) + addElemT (margins, 'top-margin', '%g' % (t * scale), lev + 3) + addElemT (margins, 'bottom-margin', '%g' % (b * scale), lev + 3) + + def mkCredits (s, score, lev): + if not s.credits: return + for ctype, ctext in s.credits.items (): + credit = E.Element ('credit', page='1') + addElemT (credit, 'credit-type', ctype, lev + 2) + addElemT (credit, 'credit-words', ctext, lev + 2) + addElem (score, credit, lev) + + def parse (s, abc_string): + abctext = abc_string if type (abc_string) == types.UnicodeType else decodeInput (abc_string) + abctext = abctext.replace ('[I:staff ','[I:staff') # avoid false beam breaks + s.reset () + header, voices = splitHeaderVoices (abctext) + ps = [] + try: + hs = abc_header.parseString (header) if header else '' + for id, vce_lyr in voices: # vce_lyr = [voice-block] where voice-block = (measures, corresponding lyric lines) + vcelyr = [] # list of measures where measure = list of elements (see syntax) + prevLeftBar = None # previous voice ended with a left-bar symbol (double repeat) + for voice, lyr in vce_lyr: + vce = abc_voice.parseString (voice).asList () + if not vce: # empty voice, insert an inline field that will be rejected + vce = [[pObj ('inline', ['I', 'empty voice'])]] + if prevLeftBar: + vce[0].insert (0, prevLeftBar) # insert at begin of first measure + prevLeftBar = None + if vce[-1] and vce[-1][-1].name == 'lbar': # last measure ends with an lbar + prevLeftBar = vce[-1][-1] + if len (vce) > 1: # vce should not become empty (-> exception when taking vcelyr [0][0]) + del vce[-1] # lbar was the only element in measure vce[-1] + lyr = lyr.strip () # strip leading \n (because we split on '\nw:...') + if lyr: # no lyrics for this measures-lyrics block + lyr = lyr_block.parseString (lyr).asList () + xs = alignLyr (vce, lyr) # put all syllables into corresponding notes + else: xs = vce + vcelyr += xs + elem1 = vcelyr [0][0] # the first element of the first measure + if elem1.name == 'inline'and elem1.t[0] == 'V': # is a voice definition + voicedef = elem1 + del vcelyr [0][0] # do not read voicedef twice + else: + voicedef = '' + ps.append ((id, voicedef, vcelyr)) + except ParseException, err: + if err.loc > 40: # limit length of error message, compatible with markInputline + err.pstr = err.pstr [err.loc - 40: err.loc + 40] + err.loc = 40 + xs = err.line[err.col-1:] + try: info (err.line.encode ('utf-8'), warn=0) # err.line is a unicode string!! + except: info (err.line.encode ('latin-1'), warn=0) + info ((err.col-1) * '-' + '^', warn=0) + if re.search (r'\[U:[XYZxyz]', xs): + info ('Error: illegal user defined symbol: %s' % xs[1:], warn=0) + elif re.search (r'\[[OAPZNGHRBDFSXTCIU]:', xs): + info ('Error: header-only field %s appears after K:' % xs[1:], warn=0) + else: + info ('Syntax error at column %d' % err.col, warn=0) + raise err + + s.unitL = (1, 8) + s.title = '' + s.creator = {} # {creator type -> name string} + s.credits = {} # {credit type -> string} + score = E.Element ('score-partwise') + attrmap = {'Div': str (s.divisions), 'K':'C treble', 'M':'4/4'} + for res in hs: + if res.name == 'field': + s.doHeaderField (res, attrmap) + else: + info ('unexpected header item: %s' % res) + + vdefs = s.voiceNamesAndMaps (ps) + vdefs = s.parseStaveDef (vdefs) + + lev = 0 + vids, parts, partAttr = [], [], {} + for vid, _, vce in ps: # voice id, voice parse tree + pname, psubnm, voicedef = vdefs [vid] # part name + attrmap ['V'] = voicedef # abc text of first voice definition (after V:vid) or empty + pid = 'P%s' % vid # let part id start with an alpha + s.vid = vid # avoid parameter passing, needed in mkNote for instrument id + part = s.mkPart (vce, pid, lev + 1, attrmap, s.gNstaves.get (vid, 0)) + if 'Q' in attrmap: del attrmap ['Q'] # header tempo only in first part + parts.append (part) + vids.append (vid) + partAttr [vid] = (pname, psubnm, s.midprg) + parts, vidsnew = mergeParts (parts, vids, s.staves) # merge parts into staves as indicated by %%score + parts, _ = mergeParts (parts, vidsnew, s.grands, 1) # merge grand staves + + s.mkIdentification (score, lev) + s.mkDefaults (score, lev + 1) + s.mkCredits (score, lev) + + partlist, nInstrs = s.mkPartlist (vids, partAttr, lev + 1) + addElem (score, partlist, lev + 1) + for ip, part in enumerate (parts): + if nInstrs [ip] < 2: # no instrument tag needed for one- or no-instrument parts + removeElems (part, 'measure/note', 'instrument') + addElem (score, part, lev + 1) + + return score + +def decodeInput (data_string): + try: enc = 'utf-8'; unicode_string = data_string.decode (enc) + except: + try: enc = 'latin-1'; unicode_string = data_string.decode (enc) + except: raise Exception ('data not encoded in utf-8 nor in latin-1') + info ('decoded from %s' % enc) + return unicode_string + +xmlVersion = "<?xml version='1.0' encoding='utf-8'?>" +def fixDoctype (elem, enc): + xs = E.tostring (elem, encoding=enc) + ys = xs.split ('\n') + if enc == 'utf-8': ys.insert (0, xmlVersion) # crooked logic of ElementTree lib + ys.insert (1, '<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 3.0 Partwise//EN" "http://www.musicxml.org/dtds/partwise.dtd">') + return '\n'.join (ys) + +def xml2mxl (pad, fnm, data): # write xml data to compressed .mxl file + from zipfile import ZipFile, ZIP_DEFLATED + fnmext = fnm + '.xml' # file name with extension, relative to the root within the archive + outfile = os.path.join (pad, fnm + '.mxl') + meta = '%s\n<container><rootfiles>\n' % xmlVersion + meta += '<rootfile full-path="%s" media-type="application/vnd.recordare.musicxml+xml"/>\n' % fnmext + meta += '</rootfiles></container>' + f = ZipFile (outfile, 'w', ZIP_DEFLATED) + f.writestr ('META-INF/container.xml', meta) + f.writestr (fnmext, data) + f.close () + info ('%s written' % outfile, warn=0) + +def convert (pad, fnm, abc_string, mxl): + # these globals should be initialised (as in the __main__ secion) before calling convert + global mxm # optimisation 1: keep instance of MusicXml + global abc_header, abc_voice, lyr_block, abc_scoredef # optimisation 2: keep computed grammars + score = mxm.parse (abc_string) + if pad: + data = fixDoctype (score, 'utf-8') + if not mxl or mxl in ['a', 'add']: + outfnm = os.path.join (pad, fnm + '.xml') + outfile = file (outfnm, 'wb') + outfile.write (data) + outfile.close () + info ('%s written' % outfnm, warn=0) + if mxl: xml2mxl (pad, fnm, data) # also write a compressed version + else: + outfile = sys.stdout + outfile.write (fixDoctype (score, 'utf-8')) + outfile.write ('\n') + +#---------------- +# Main Program +#---------------- +if __name__ == '__main__': + from optparse import OptionParser + from glob import glob + import time + global mxm # keep instance of MusicXml + global abc_header, abc_voice, lyr_block, abc_scoredef # keep computed grammars + mxm = MusicXml () + + parser = OptionParser (usage='%prog [-h] [-r] [-m SKIP NUM] [-o DIR] [-p PFMT] [-z MODE] <file1> [<file2> ...]', version='version %d' % VERSION) + parser.add_option ("-o", action="store", help="store xml files in DIR", default='', metavar='DIR') + parser.add_option ("-m", action="store", help="skip SKIP tunes, then read at most NUM tunes", nargs=2, type='int', default=(0,1), metavar='SKIP NUM') + parser.add_option ("-p", action="store", help="page formatting in PFMT", default='', metavar='PFMT') + parser.add_option ("-z", "--mxl", dest="mxl", help="store as compressed mxl, MODE = a(dd) or r(eplace)", default='', metavar='MODE') + parser.add_option ("-r", action="store_true", help="show whole measure rests in merged staffs", default=False) + options, args = parser.parse_args () + if len (args) == 0: parser.error ('no input file given') + pad = options.o + if options.mxl and options.mxl not in ['a','add', 'r', 'replace']: + parser.error ('MODE should be a(dd) or r(eplace), not: %s' % options.mxl) + if pad: + if not os.path.exists (pad): os.mkdir (pad) + if not os.path.isdir (pad): parser.error ('%s is not a directory' % pad) + if options.p: # set page formatting values + try: # space, page-height, -width, margin-left, -right, -top, -bottom + mxm.pageFmtCmd = map (float, options.p.split (',')) + if len (mxm.pageFmtCmd) != 7: raise Exception ('-p needs 7 values') + except Exception, err: parser.error (err) + mxm.gmwr = options.r # ugly: needs to be globally accessable + + abc_header, abc_voice, lyr_block, abc_scoredef = abc_grammar () # compute grammar only once per file set + fnmext_list = [] + for i in args: fnmext_list += glob (i) + if not fnmext_list: parser.error ('none of the input files exist') + t_start = time.time () + for X, fnmext in enumerate (fnmext_list): + fnm, ext = os.path.splitext (fnmext) + if ext.lower () not in ('.abc'): + info ('skipped input file %s, it should have extension .abc' % fnmext) + continue + if os.path.isdir (fnmext): + info ('skipped directory %s. Only files are accepted' % fnmext) + continue + + fobj = open (fnmext, 'rb') + encoded_data = fobj.read () + fobj.close () + fragments = encoded_data.split ('X:') + preamble = fragments [0] # tunes can be preceeded by formatting instructions + tunes = fragments[1:] + if not tunes and preamble: tunes, preamble = ['1\n' + preamble], '' # tune without X: + skip, num = options.m # skip tunes, then read at most num tunes + numtunes = min ([len (tunes), num]) # number of tunes to be converted + for itune, tune in enumerate (tunes): + if itune < skip: continue + if itune >= skip + num: break + tune = preamble + 'X:' + tune # restore preamble before each tune + fnmNum = '%s%02d' % (fnm, itune + 1) if numtunes > 1 else fnm + try: # convert string abctext -> file pad/fnmNum.xml + convert (pad, fnmNum, tune, options.mxl) + except ParseException, err: pass # output already printed + except Exception, err: info ('an exception occurred.\n%s' % err) + info ('done in %.2f secs' % (time.time () - t_start))