From 95b2356dd119b6dc9f56adeb57fdfa9752efb529 Mon Sep 17 00:00:00 2001 From: fred Date: Thu, 17 Aug 2000 22:25:13 +0000 Subject: [PATCH] lilypond-1.3.79 --- CHANGES | 28 ++- VERSION | 2 +- scripts/etf2ly.py | 730 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 757 insertions(+), 3 deletions(-) create mode 100644 scripts/etf2ly.py diff --git a/CHANGES b/CHANGES index d46d267c6c..e13358409d 100644 --- a/CHANGES +++ b/CHANGES @@ -1,6 +1,31 @@ -1.3.77.jcn5 +* etf2ly.py: Finale to LilyPond conversion. + +1.3.78.jcn4 =========== +* Made simple fix to get part-combiner to recognise different rhythms + +* Unhardcoded part combiner and a2-engraver; introduced properties + splitInterval, soloADue, soloText, soloIIText, aDueText. + +* Fixed part combiner's too-late problem (Dankje!) + +* Fixed a2-devnull-engraver, a2-engraver. + +* Renamed part combiner music names to "one", "two". + +* Cleaned up decision making in part combiner, renamed to "solo"/"unison" + +1.3.77.mb1 +========== + +* Minor documentation updates + +* Mark_engraver: has been broken since .73, fixed! + +1.3.78 +====== + * Added a devnull engraver, that junks (notehead) requests of the second stem when combined parts are in unison (a2). @@ -13,7 +38,6 @@ * First try at combining parts: part-combine* - * fixed problem with HaraKiri * fixed problem with dynamicDirection diff --git a/VERSION b/VERSION index ba678f5afe..cfec8508be 100644 --- a/VERSION +++ b/VERSION @@ -1,7 +1,7 @@ PACKAGE_NAME=LilyPond MAJOR_VERSION=1 MINOR_VERSION=3 -PATCH_LEVEL=78 +PATCH_LEVEL=79 MY_PATCH_LEVEL= # use the above to send patches: MY_PATCH_LEVEL is always empty for a diff --git a/scripts/etf2ly.py b/scripts/etf2ly.py new file mode 100644 index 0000000000..7a99aeeb6d --- /dev/null +++ b/scripts/etf2ly.py @@ -0,0 +1,730 @@ +#!@PYTHON@ + +# info taken from + +# * convertmusic (see sourceforge) +# * Margaret Cahill's thesis +# * http://www.codamusic.com/coda/Fin2000_pdk_download.asp (you have +# to register, but you don't need to have bought a code product + +# +# This supports + +# +# * notes +# * rests +# * ties +# * slurs +# + +# todo: +# * slur/stem directions +# * articulation +# * voices (2nd half of frame?) +# * lyrics +# * beams (better use autobeam?) + +program_name = 'etf2ly' +version = '@TOPLEVEL_VERSION@' +if version == '@' + 'TOPLEVEL_VERSION' + '@': + version = '(unknown version)' # uGUHGUHGHGUGH + +import __main__ +import getopt +import sys +import re +import string +import os + + + +finale_clefs= ['treble', 'alto', 'tenor', 'bass', 'percussion', 'treble8vb', 'bass8vb', 'baritone'] + + +def lily_clef (fin): + return finale_clefs[fin] + +def gulp_file(f): + return open (f).read () + +# notename 0 == central C +distances = [0, 2, 4, 5, 7, 9, 11, 12] +def semitones (name, acc): + return (name / 7 ) * 12 + distances[name % 7] + acc + +def transpose(orig, delta): + (oname, oacc) = orig + (dname, dacc) = delta + + old_pitch =semitones (oname, oacc) + delta_pitch = semitones (dname, dacc) + nname = (oname + dname) + nacc = oacc + new_pitch = semitones (nname, nacc) + + nacc = nacc - (new_pitch - old_pitch - delta_pitch) + + return (nname, nacc) + + + +# find transposition of C-major scale that belongs here. +def interpret_finale_key_sig (finale_id): + p = (0,0) + if 0 <= finale_id < 7: + while finale_id > 0: + p = transpose (p, (4,0)) # a fifth up + finale_id = finale_id - 1 + elif 248 < finale_id <= 255: + while finale_id < 256: + p = transpose (p, (3,0)) + finale_id = finale_id + 1 + + p = (p[0] % 7, p[1]) + return p + +# should cache this. +def find_scale (transposition): + cscale = map (lambda x: (x,0), range (0,7)) + trscale = map(lambda x, k=transposition: transpose(x, k), cscale) + + return trscale + +def gcd (a,b): + if b == 0: + return a + c = a + while c: + c = a % b + a = b + b = c + return a + + +def rat_simplify (r): + (n,d) = r + if d < 0: + d = -d + n = -n + if n == 0: + return (0,1) + else: + g = gcd (n, d) + return (n/g, d/g) + +def rat_multiply (a,b): + (x,y) = a + (p,q) = b + + return rat_simplify ((x*p, y*q)) + +def rat_add (a,b): + (x,y) = a + (p,q) = b + + return rat_simplify ((x*q + p*y, y*q)) + +def rat_neg (a): + (p,q) = a + return (-p,q) + +def rat_subtract (a,b ): + return rat_add (a, rat_neg (b)) + +def lily_notename (tuple2): + (n, a) = tuple2 + nn = chr ((n+ 2)%7 + ord ('a')) + + if a == -1: + nn = nn + 'es' + elif a == -2: + nn = nn + 'eses' + elif a == 1: + nn = nn + 'is' + elif a == 2: + nn = nn + 'isis' + + return nn + +class Slur: + def __init__ (self, number): + self.number = number + self.finale = [] + + def append_entry (self, finale_e): + self.finale.append (finale_e) + + def calculate (self, chords): + startnote = self.finale[0][5] + endnote = self.finale[3][2] + + cs = chords[startnote] + cs.suffix = '(' + cs.suffix + ce = chords[endnote] + ce.prefix = ce.prefix + ')' + +class Global_measure: + def __init__ (self, number): + self.timesig = '' + self.number = number + self.keysignature = None + self.scale = None + + self.finale = [] + + def set_timesig (self, finale): + (beats, fdur) = finale + (log, dots) = EDU_to_duration (fdur) + assert dots == 0 + self.timesig = (beats, log) + + def length (self): + return self.timesig + + def set_keysig (self, finale): + k = interpret_finale_key_sig (finale) + self.keysignature = k + self.scale = find_scale (k) + + + +class Measure: + def __init__(self, no): + self.number = no + self.frames = [] + self.flags = 0 + self.clef = 0 + self.finale = [] + self.global_measure = None + + def add_finale_entry (self, entry): + self.finale.append (entry) + + def calculate (self): + f0 = self.finale[0] + f1 = self.finale[1] + + self.clef = string.atoi (f0[0]) + self.flags = string.atoi (f0[1]) + fs = map (string.atoi, list (f0[2:]) + [f1[0]]) + + self.frames = fs + +class Frame: + def __init__ (self, finale): + self.measure = None + self.finale = finale + (number, start, end ) = finale + self.number = number + self.start = start + self.end = end + self.chords = [] + + def set_measure (self, m): + self.measure = m + + def dump (self): + str = '' + left = self.measure.global_measure.length () + for c in self.chords: + str = str + c.ly_string () + ' ' + left = rat_subtract (left, c.length ()) + if left[0] < 0: + print self.number + print self.start, self.end + print left + raise 'bla' + if left[0]: + str = str + 's*%d/%d' % left + + str = str + '\n' + return str + +class Staff: + def __init__ (self, number): + self.number = number + self.measures = [] + + def get_measure (self, no): + if len (self.measures) <= no: + self.measures = self.measures + [None]* (1 + no - len (self.measures)) + + if self.measures[no] == None: + self.measures [no] = Measure (no) + + return self.measures[no] + def staffid (self): + return 'staff%s'% chr (self.number - 1 +ord ('A')) + def layerid (self, l): + return self.staffid() + 'layer%s' % chr (l -1 + ord ('A')) + + def dump_time_key_sigs (self): + k = '' + last_key = None + last_time = None + last_clef = None + gap = (0,1) + for m in self.measures[1:]: + g = m.global_measure + e = '' + if last_key <> g.keysignature: + e = e + "\\key %s \\major; " % lily_notename (g.keysignature) + last_key = g.keysignature + if last_time <> g.timesig : + e = e + "\\time %d/%d; " % g.timesig + last_time = g.timesig + if last_clef <> m.clef : + e = e + '\\clef %s;' % lily_clef (m.clef) + last_clef = m.clef + if e: + if gap <> (0,1): + k = k +' s1*%d/%d \n ' % gap + gap = (0,1) + k = k + e + + gap = rat_add (gap, g.length ()) + + + k = '%sglobal = \\notes { %s }\n\n ' % (self.staffid (), k) + return k + + def dump (self): + str = '' + + + layerids = [] + for x in range (1,5): # 4 layers. + laystr = '' + last_frame = None + first_frame = None + gap = (0,1) + for m in self.measures[1:]: + fr = m.frames[x] + if fr: + first_frame = fr + if gap <> (0,1): + laystr = laystr +'} s1*%d/%d {\n ' % gap + gap = (0,1) + laystr = laystr + fr.dump () + else: + gap = rat_add (gap, m.global_measure.length ()) + + if first_frame: + l = self.layerid (x) + laystr = '%s = \\notes { { %s } }\n\n' % (l, laystr) + str = str + laystr + layerids.append (l) + + str = str + self.dump_time_key_sigs () + stafdef = '\\%sglobal' % self.staffid () + for i in layerids: + stafdef = stafdef + ' \\' + i + + + str = str + '%s = \\context Staff = %s <\n %s\n >\n' % \ + (self.staffid (), self.staffid (), stafdef) + return str + + +def EDU_to_duration (edu): + log = 1 + d = 4096 + while d > edu: + d = d >> 1 + log = log << 1 + + edu = edu - d + dots = 0 + if edu == d /2: + dots = 1 + elif edu == d*3/4: + dots = 2 + return (log, dots) + +class Chord: + def __init__ (self, finale_entry): + self.pitches = [] + self.frame = None + self.finale = finale_entry + self.duration = None + self.next = None + self.prev = None + self.prefix= '' + self.suffix = '' + def measure (self): + if not self.frame: + return None + return self.frame.measure + + def length (self): + l = (1, self.duration[0]) + + d = 1 << self.duration[1] + + dotfact = rat_subtract ((2,1), (1,d)) + return rat_multiply (dotfact, l) + + def number (self): + return self.finale[0][0] + def set_duration (self): + ((no, prev, next, dur, pos, entryflag, extended, follow), + notelist) = self.finale + self.duration = EDU_to_duration(dur) + def find_realpitch (self): + + ((no, prev, next, dur, pos, entryflag, extended, follow), notelist) = self.finale + + meas = self.measure () + tiestart = 0 + if not meas or not meas.global_measure : + print 'note %d not in measure' % self.number () + elif not meas.global_measure.scale: + print 'note %d: no scale in this measure.' % self.number () + else: + for p in notelist: + (pitch, flag) = p + + nib1 = pitch & 0x0f + if nib1 > 8: + nib1 = -(nib1 - 8) + rest = pitch / 16 + + scale = meas.global_measure.scale + (sn, sa) =scale[rest % 7] + sn = sn + (rest - (rest%7)) + 7 + acc = sa + nib1 + self.pitches.append ((sn, acc)) + tiestart = tiestart or (flag & Chord.TIE_START_MASK) + if tiestart : + self.suffix = self.suffix + ' ~ ' + + REST_MASK = 0x40000000L + TIE_START_MASK = 0x40000000L + def ly_string (self): + s = '' + + rest = '' + + if not (self.finale[0][5] & Chord.REST_MASK): + rest = 'r' + + for p in self.pitches: + (n,a) = p + o = n/ 7 + n = n % 7 + + nn = lily_notename ((n,a)) + + if o < 0: + nn = nn + (',' * -o) + elif o > 0: + nn = nn + ('\'' * o) + + if s: + s = s + ' ' + + if rest: + nn = rest + + s = s + '%s%d%s' % (nn, self.duration[0], '.'* self.duration[1]) + + if len (self.pitches) > 1: + s = '<%s>' % s + elif not self.pitches: + s = 'r%d%s' % (self.duration[0] , '.'* self.duration[1]) + + s = self.prefix + s + self.suffix + return s + +GFre = re.compile(r"""^\^GF\(([0-9-]+),([0-9-]+)\) ([0-9-]+) ([0-9-]+) ([0-9-]+) ([0-9-]+) ([0-9-]+)""") +BCre = re.compile (r"""^\^BC\(([0-9-]+)\) ([0-9-]+) .*$""") +eEre = re.compile(r"""^\^eE\(([0-9-]+)\) ([0-9-]+) ([0-9-]+) ([0-9-]+) ([0-9-]+) \$([0-9A-Fa-f]+) ([0-9-]+) ([0-9-]+)""") +FRre = re.compile (r"""^\^FR\(([0-9-]+)\) ([0-9-]+) ([0-9-]+) ([0-9-]+) ([0-9-]+)""") +MSre = re.compile (r"""^\^MS\(([0-9-]+)\) ([0-9-]+) ([0-9-]+) ([0-9-]+) ([0-9-]+) ([0-9-]+)""") +note_re = re.compile (r"""^ +([0-9-]+) \$([A-Fa-f0-9]+)""") +Sxre = re.compile (r"""^\^Sx\(([0-9-]+)\) ([0-9-]+) ([0-9-]+) ([0-9-]+) ([0-9-]+) ([0-9-]+) ([0-9-]+)""") + +class Etf_file: + def __init__ (self, name): + self.measures = [None] + self.entries = [None] + self.chords = [None] + self.frames = [None] + self.staffs = [None] + self.slurs = [None] + + ## do it + self.parse (name) + + def get_global_measure (self, no): + if len (self.measures) <= no: + self.measures = self.measures + [None]* (1 + no - len (self.measures)) + + if self.measures[no] == None: + self.measures [no] = Global_measure (no) + + return self.measures[no] + + + def get_staff(self,staffno): + if len (self.staffs) <= staffno: + self.staffs = self.staffs + [None] * (1 + staffno - len (self.staffs)) + + if self.staffs[staffno] == None: + self.staffs[staffno] = Staff (staffno) + + return self.staffs[staffno] + + # staff-spec + def try_IS (self, l): + pass + + def try_BC (self, l): + m = BCre.match (l) + if m: + bn = string.atoi (m.group (1)) + where = string.atoi (m.group (2)) / 1024.0 + return m + + def try_eE (self, l): + m = eEre.match (l) + if m: + tup = m.groups() + (no, prev, next, dur, pos, entryflag, extended, follow) = tup + (no, prev, next, dur, pos,extended, follow) \ + = tuple (map (string.atoi, [no,prev,next,dur,pos,extended,follow])) + + entryflag = string.atol (entryflag,16) + assert (no==len (self.entries)) + current_entry = ((no, prev, next, dur, pos, entryflag, extended, follow), []) + self.entries.append (current_entry) + return m + + def try_Sx(self,l): + m = Sxre.match (l) + if m: + slurno = string.atoi (m.group (1)) + + if len (self.slurs) == slurno: + self.slurs.append (Slur (slurno)) + + params = list (m.groups ()[1:]) + params = map (string.atoi, params) + self.slurs[-1].append_entry (params) + + return m + def try_GF(self, l): + m = GFre.match (l) + if m: + (staffno,measno) = m.groups ()[0:2] + s = string.atoi (staffno) + me = string.atoi (measno) + + entry = m.groups () [2:] + st = self.get_staff (s) + meas = st.get_measure (me) + meas.add_finale_entry (entry) + + # frame ? + def try_FR(self, l): + m = FRre.match (l) + if m: + (frameno, startnote, endnote, foo, bar) = m.groups () + (frameno, startnote, endnote) = tuple (map (string.atoi, [frameno, startnote, endnote])) + self.frames.append (Frame ((frameno, startnote, endnote))) + + return m + def try_MS (self, l): + m = MSre.match (l) + if m: + measno = string.atoi (m.group (1)) + keynum = string.atoi (m.group (3)) + meas =self. get_global_measure (measno) + meas.set_keysig (keynum) + + beats = string.atoi (m.group (4)) + beatlen = string.atoi (m.group (5)) + meas.set_timesig ((beats, beatlen)) + + return m + + def try_note (self, l): + m = note_re.match (l) + if m: + (pitch, flag) = m.groups () + pitch = string.atoi (pitch) + flag = string.atol (flag,16) + self.entries[-1][1].append ((pitch,flag)) + + def parse (self, name): + sys.stderr.write ('parsing ...') + sys.stderr.flush () + + ls = open (name).readlines () + for l in ls: + m = None + if not m: + m = self.try_MS (l) + if not m: + m = self.try_FR (l) + if not m: + m = self.try_GF (l) + if not m: + m = self.try_note (l) + if not m: + m = self.try_eE (l) + if not m: + m = self.try_Sx (l) + + sys.stderr.write ('processing ...') + sys.stderr.flush () + + self.unthread_entries () + + for st in self.staffs[1:]: + if not st: + continue + mno = 1 + for m in st.measures[1:]: + m.global_measure = self.measures[mno] + m.calculate() + + frame_obj_list = [None] + for frno in m.frames: + fr = self.frames[frno] + frame_obj_list.append (fr) + + m.frames = frame_obj_list + for fr in frame_obj_list[1:]: + if not fr: + continue + + fr.set_measure (m) + + fr.chords = self.get_thread (fr.start, fr.end) + for c in fr.chords: + c.frame = fr + mno = mno + 1 + + for c in self.chords[1:]: + c.find_realpitch () + c.set_duration () + + for s in self.slurs [1:]: + s.calculate (self.chords) + + def get_thread (self, startno, endno): + + thread = [] + c = self.chords[startno] + while c and c.number () <> endno: + thread.append (c) + c = c.next + + if c: + thread.append (c) + + return thread + + def dump (self): + str = '' + staffs = [] + for s in self.staffs[1:]: + if s: + str = str + '\n\n' + s.dump () + staffs.append ('\\' + s.staffid ()) + + if staffs: + str = str + '\\score { < %s > } ' % string.join (staffs) + + + return str + + + def __str__ (self): + return self.dump () + + def unthread_entries (self): + self.chords = [None] + for e in self.entries[1:]: + self.chords.append (Chord (e)) + + for e in self.chords[1:]: + e.prev = self.chords[e.finale[0][1]] + e.next = self.chords[e.finale[0][2]] + + + + + + +def identify(): + sys.stderr.write ("%s from LilyPond %s\n" % (program_name, version)) + +def help (): + print r""" +Convert ETF to LilyPond. + +Usage: etf2ly [OPTION]... ETF-FILE + +Options: + -h, --help this help + -o, --output=FILE set output filename to FILE + -v, --version version information + +Enigma Transport Format is a format used by Coda Music Technology's +Finale product. This program will convert a subset of ETF to a +ready-to-use lilypond file. + + +""" + +def print_version (): + print r"""etf2ly (GNU lilypond) %s""" % version + + + +(options, files) = getopt.getopt (sys.argv[1:], 'vo:h', ['help','version', 'output=']) +out_filename = None + +for opt in options: + o = opt[0] + a = opt[1] + if o== '--help' or o == '-h': + help () + sys.exit (0) + if o == '--version' or o == '-v': + print_version () + sys.exit(0) + + if o == '--output' or o == '-o': + out_filename = a + else: + print o + raise getopt.error + +identify() + +# header['tagline'] = 'Lily was here %s -- automatically converted from ABC' % version +for f in files: + if f == '-': + f = '' + + sys.stderr.write ('Processing `%s\'\n' % f) + e = Etf_file(f) + if not out_filename: + out_filename = os.path.basename (re.sub ('.etf$', '.ly', f)) + + if out_filename == f: + out_filename = os.path.basename (f + '.ly') + + sys.stderr.write ('Writing `%s\'' % out_filename) + ly = e.dump() + + + + fo = open (out_filename, 'w') + fo.write ('%% lily was here -- automatically converted by etf2ly from %s\n' % f) + fo.write(ly) + fo.close () + -- 2.11.4.GIT