scripts/etf2ly.py

   1 #!@PYTHON@
   2
   3 # info mostly taken from looking at files. See also
   4 # http://lilypond.org/wiki/?EnigmaTransportFormat
   5
   6 # This supports
   7 #
   8 #  * notes
   9 #  * rests
  10 #  * ties
  11 #  * slurs
  12 #  * lyrics
  13 #  * articulation
  14 #  * grace notes
  15 #  * tuplets
  16 #
  17
  18 # todo:
  19 #  * slur/stem directions
  20 #  * voices (2nd half of frame?)
  21 #  * more intelligent lyrics
  22 #  * beams (better use autobeam?)
  23 #  * more robust: try entertainer.etf (freenote)
  24 #  * dynamics
  25 #  * empty measures (eg. twopt03.etf from freenote)
  26 #
  27
  28
  29 import __main__
  30 import getopt
  31 import sys
  32 import re
  33 import string
  34 import os
  35
  36 program_name = sys.argv[0]
  37
  38 version = '@TOPLEVEL_VERSION@'
  39 if version == '@' + 'TOPLEVEL_VERSION' + '@':
  40         version = '(unknown version)'      # uGUHGUHGHGUGH
  41
  42
  43 ################################################################
  44 # Users of python modules should include this snippet.
  45 #
  46 libdir = '@local_lilypond_libdir@'
  47 if not os.path.isdir (libdir):
  48         libdir = '@lilypond_libdir@'
  49
  50 # ugh
  51 datadir = '@local_lilypond_datadir@'
  52 if os.environ.has_key ('LILYPONDPREFIX'):
  53         datadir = os.environ['LILYPONDPREFIX']
  54         while datadir[-1] == os.sep:
  55                 datadir= datadir[:-1]
  56         libdir = datadir.replace ('/share/', '/lib/')
  57
  58 if os.path.exists (os.path.join (datadir, 'lib/lilypond/@TOPLEVEL_VERSION@/')):
  59         libdir = os.path.join (libdir, 'lib/lilypond/@TOPLEVEL_VERSION@/')
  60
  61 if os.path.exists (os.path.join (datadir, 'lib/lilypond/current/')):
  62         libdir = os.path.join (libdir, 'lib/lilypond/current/')
  63
  64 sys.path.insert (0, os.path.join (libdir, 'python'))
  65
  66 # dynamic relocation, for GUB binaries.
  67 bindir = os.path.split (sys.argv[0])[0]
  68 for p in ['share', 'lib']:
  69         datadir = os.path.abspath (bindir + '/../%s/lilypond/current/python/' % p)
  70         sys.path.insert (0, datadir)
  71
  72 ################################################################
  73
  74 import lilylib as ly
  75 _ = ly._
  76
  77 finale_clefs= ['treble', 'alto', 'tenor', 'bass', 'percussion', 'treble_8', 'bass_8', 'baritone']
  78
  79 def lily_clef (fin):
  80         try:
  81                 return finale_clefs[fin]
  82         except IndexError:
  83                 sys.stderr.write ( '\nHuh? Found clef number %d\n' % fin)
  84
  85         return 'treble'
  86
  87
  88
  89 def gulp_file(f):
  90         return open (f).read ()
  91
  92 # notename 0 == central C
  93 distances = [0, 2, 4, 5, 7, 9, 11, 12]
  94 def semitones (name, acc):
  95         return (name / 7 ) * 12 + distances[name % 7] + acc
  96
  97 # represent pitches as (notename, alteration), relative to C-major scale
  98 def transpose(orig, delta):
  99         (oname, oacc) = orig
 100         (dname, dacc) = delta
 101
 102         old_pitch =semitones (oname, oacc)
 103         delta_pitch = semitones (dname, dacc)
 104         nname = (oname + dname)
 105         nacc = oacc
 106         new_pitch = semitones (nname, nacc)
 107
 108         nacc = nacc - (new_pitch - old_pitch - delta_pitch)
 109
 110         return (nname, nacc)
 111
 112
 113
 114 def interpret_finale_key_sig (finale_id):
 115         """
 116 find the transposition of C-major scale that belongs here.
 117
 118 we are not going to insert the correct major/minor, we only want to
 119 have the correct number of accidentals
 120 """
 121
 122         p = (0,0)
 123
 124
 125         bank_number = finale_id >> 8
 126         accidental_bits = finale_id & 0xff
 127
 128         if 0 <= accidental_bits < 7:
 129                 while accidental_bits > 0:
 130                         p = transpose (p, (4,0)) # a fifth up
 131                         accidental_bits = accidental_bits - 1
 132         elif 248 < accidental_bits <= 255:
 133                 while accidental_bits < 256:
 134                         p = transpose (p, (3,0))
 135                         accidental_bits = accidental_bits + 1
 136
 137         if bank_number == 1:
 138                 # minor scale
 139                 p = transpose (p, (5, 0))
 140         p  = (p[0] % 7, p[1])
 141
 142         return KeySignature (p, bank_number)
 143
 144 # should cache this.
 145 def find_scale (keysig):
 146         cscale = map (lambda x: (x,0), range (0,7))
 147 #       print "cscale: ", cscale
 148         ascale = map (lambda x: (x,0), range (-2,5))
 149 #       print "ascale: ", ascale
 150         transposition = keysig.pitch
 151         if keysig.sig_type == 1:
 152                 transposition = transpose(transposition, (2, -1))
 153                 transposition = (transposition[0] % 7, transposition[1])
 154                 trscale = map(lambda x, k=transposition: transpose(x, k), ascale)
 155         else:
 156                 trscale = map(lambda x, k=transposition: transpose(x, k), cscale)
 157 #       print "trscale: ", trscale
 158         return trscale
 159
 160 def EDU_to_duration (edu):
 161         log = 1
 162         d = 4096
 163         while d > edu:
 164                 d = d >> 1
 165                 log = log << 1
 166
 167         edu = edu - d
 168         dots = 0
 169         if edu == d /2:
 170                 dots = 1
 171         elif edu == d*3/4:
 172                 dots = 2
 173         return (log, dots)
 174
 175 def rational_to_lily_skip (rat):
 176         (n,d) = rat
 177
 178         basedur = 1
 179         while d and  d % 2 == 0:
 180                 basedur = basedur << 1
 181                 d = d >> 1
 182
 183         str = 's%d' % basedur
 184         if n <> 1:
 185                 str = str + '*%d' % n
 186         if d <> 1:
 187                 str = str + '/%d' % d
 188
 189         return str
 190
 191 def gcd (a,b):
 192         if b == 0:
 193                 return a
 194         c = a
 195         while c:
 196                 c = a % b
 197                 a = b
 198                 b = c
 199         return a
 200
 201
 202 def rat_simplify (r):
 203         (n,d) = r
 204         if d < 0:
 205                 d = -d
 206                 n = -n
 207         if n == 0:
 208                 return (0,1)
 209         else:
 210                 g = gcd (n, d)
 211                 return (n/g, d/g)
 212
 213 def rat_multiply (a,b):
 214         (x,y) = a
 215         (p,q) = b
 216
 217         return rat_simplify ((x*p, y*q))
 218
 219 def rat_add (a,b):
 220         (x,y) = a
 221         (p,q) = b
 222
 223         return rat_simplify ((x*q + p*y, y*q))
 224
 225 def rat_neg (a):
 226         (p,q) = a
 227         return (-p,q)
 228
 229
 230
 231 def rat_subtract (a,b ):
 232         return rat_add (a, rat_neg (b))
 233
 234 def lily_notename (tuple2):
 235         (n, a) = tuple2
 236         nn = chr ((n+ 2)%7 + ord ('a'))
 237
 238         return nn + {-2:'eses', -1:'es', 0:'', 1:'is', 2:'isis'}[a]
 239
 240
 241 class Tuplet:
 242         def __init__ (self, number):
 243                 self.start_note = number
 244                 self.finale = []
 245
 246         def append_finale (self, fin):
 247                 self.finale.append (fin)
 248
 249         def factor (self):
 250                 n = self.finale[0][2]*self.finale[0][3]
 251                 d = self.finale[0][0]*self.finale[0][1]
 252                 return rat_simplify( (n, d))
 253
 254         def dump_start (self):
 255                 return '\\times %d/%d { ' % self.factor ()
 256
 257         def dump_end (self):
 258                 return ' }'
 259
 260         def calculate (self, chords):
 261                 edu_left = self.finale[0][0] * self.finale[0][1]
 262
 263                 startch = chords[self.start_note]
 264                 c = startch
 265                 while c and edu_left:
 266                         c.tuplet = self
 267                         if c == startch:
 268                                 c.chord_prefix = self.dump_start () + c.chord_prefix
 269
 270                         if not c.grace:
 271                                 edu_left = edu_left - c.EDU_duration ()
 272                         if edu_left == 0:
 273                                 c.chord_suffix = c.chord_suffix+ self.dump_end ()
 274                         c = c.next
 275
 276                 if edu_left:
 277                         sys.stderr.write ("\nHuh? Tuplet starting at entry %d was too short." % self.start_note)
 278
 279 class Slur:
 280         def __init__ (self, number, params):
 281                 self.number = number
 282                 self.finale = params
 283
 284         def append_entry (self, finale_e):
 285                 self.finale.append (finale_e)
 286
 287         def calculate (self, chords):
 288                 startnote = self.finale[5]
 289                 endnote = self.finale[3*6 + 2]
 290                 try:
 291                         cs = chords[startnote]
 292                         ce = chords[endnote]
 293
 294                         if not cs or not ce:
 295                                 raise IndexError
 296
 297                         cs.note_suffix = '-(' + cs.note_suffix
 298                         ce.note_suffix = ce.note_suffix + '-)'
 299
 300                 except IndexError:
 301                         sys.stderr.write ("""\nHuh? Slur no %d between (%d,%d), with %d notes""" % (self.number,  startnote, endnote, len (chords)))
 302
 303
 304 class Global_measure:
 305         def __init__ (self, number):
 306                 self.timesig = ''
 307                 self.number = number
 308                 self.key_signature = None
 309                 self.scale = None
 310                 self.force_break = 0
 311
 312                 self.repeats = []
 313                 self.finale = []
 314
 315         def __str__ (self):
 316                 return `self.finale `
 317
 318         def set_timesig (self, finale):
 319                 (beats, fdur) = finale
 320                 (log, dots) = EDU_to_duration (fdur)
 321
 322                 if dots == 1:
 323                         beats = beats * 3
 324                         log = log * 2
 325                         dots = 0
 326
 327                 if dots <> 0:
 328                         sys.stderr.write ("\nHuh? Beat duration has  dots? (EDU Duration = %d)" % fdur)
 329                 self.timesig = (beats, log)
 330
 331         def length (self):
 332                 return self.timesig
 333
 334         def set_key_sig (self, finale):
 335                 k = interpret_finale_key_sig (finale)
 336                 self.key_signature = k
 337                 self.scale = find_scale (k)
 338
 339         def set_flags (self,flag1, flag2):
 340
 341                 # flag1 isn't all that interesting.
 342                 if flag2 & 0x8000:
 343                         self.force_break = 1
 344
 345                 if flag2 & 0x0008:
 346                         self.repeats.append ('start')
 347                 if flag2 & 0x0004:
 348                         self.repeats.append ('stop')
 349
 350                 if flag2 & 0x0002:
 351                         if flag2 & 0x0004:
 352                                 self.repeats.append ('bracket')
 353
 354 articulation_dict ={
 355         94: '^',
 356         109: '\\prall',
 357         84: '\\turn',
 358         62: '\\mordent',
 359         85: '\\fermata',
 360         46: '.',
 361 #       3: '>',
 362 #       18: '\arpeggio' ,
 363 }
 364
 365 class Articulation_def:
 366         def __init__ (self, n, a, b):
 367                 self.finale_glyph = a & 0xff
 368                 self.number = n
 369
 370         def dump (self):
 371                 try:
 372                         return articulation_dict[self.finale_glyph]
 373                 except KeyError:
 374                         sys.stderr.write ("\nUnknown articulation no. %d" % self.finale_glyph)
 375                         sys.stderr.write ("\nPlease add an entry to articulation_dict in the Python source")
 376                         return None
 377
 378 class Articulation:
 379         def __init__ (self, a,b, finale):
 380                 self.definition = finale[0]
 381                 self.notenumber = b
 382
 383         def calculate (self, chords, defs):
 384                 c = chords[self.notenumber]
 385
 386                 adef = defs[self.definition]
 387                 lystr =adef.dump()
 388                 if lystr == None:
 389                         lystr = '"art"'
 390                         sys.stderr.write ("\nThis happened on note %d" % self.notenumber)
 391
 392                 c.note_suffix = '-' + lystr
 393
 394 class Syllable:
 395         def __init__ (self, a,b , finale):
 396                 self.chordnum = b
 397                 self.syllable = finale[1]
 398                 self.verse = finale[0]
 399         def calculate (self, chords, lyrics):
 400                 self.chord = chords[self.chordnum]
 401
 402 class Verse:
 403         def __init__ (self, number, body):
 404                 self.body = body
 405                 self.number = number
 406                 self.split_syllables ()
 407         def split_syllables (self):
 408                 ss = re.split ('(-| +)', self.body)
 409
 410                 sep = 0
 411                 syls = [None]
 412                 for s in ss:
 413                         if sep:
 414                                 septor = re.sub (" +", "", s)
 415                                 septor = re.sub ("-", " -- ", septor)
 416                                 syls[-1] = syls[-1] + septor
 417                         else:
 418                                 syls.append (s)
 419
 420                         sep = not sep
 421
 422                 self.syllables = syls
 423
 424         def dump (self):
 425                 str = ''
 426                 line = ''
 427                 for s in self.syllables[1:]:
 428                         line = line + ' ' + s
 429                         if len (line) > 72:
 430                                 str = str + ' ' * 4 + line + '\n'
 431                                 line = ''
 432
 433                 str = """\nverse%s = \\lyricmode {\n %s }\n""" %  (encodeint (self.number - 1) ,str)
 434                 return str
 435
 436 class KeySignature:
 437         def __init__(self, pitch, sig_type = 0):
 438                 self.pitch = pitch
 439                 self.sig_type = sig_type
 440
 441         def signature_type (self):
 442                 if self.sig_type == 1:
 443                         return "\\minor"
 444                 else:
 445                         # really only for 0, but we only know about 0 and 1
 446                         return "\\major"
 447
 448         def equal (self, other):
 449                 if other and other.pitch == self.pitch and other.sig_type == self.sig_type:
 450                         return 1
 451                 else:
 452                         return 0
 453
 454
 455 class Measure:
 456         def __init__(self, no):
 457                 self.number = no
 458                 self.frames = [0] * 4
 459                 self.flags = 0
 460                 self.clef = 0
 461                 self.finale = []
 462                 self.global_measure = None
 463                 self.staff = None
 464                 self.valid = 1
 465
 466
 467         def valid (self):
 468                 return self.valid
 469         def calculate (self):
 470                 fs = []
 471
 472                 if len (self.finale) < 2:
 473                         fs = self.finale[0]
 474
 475                         self.clef = fs[1]
 476                         self.frames = [fs[0]]
 477                 else:
 478                         fs = self.finale
 479                         self.clef = fs[0]
 480                         self.flags = fs[1]
 481                         self.frames = fs[2:]
 482
 483
 484 class Frame:
 485         def __init__ (self, finale):
 486                 self.measure = None
 487                 self.finale = finale
 488                 (number, start, end ) = finale
 489                 self.number = number
 490                 self.start = start
 491                 self.end = end
 492                 self.chords  = []
 493
 494         def set_measure (self, m):
 495                 self.measure = m
 496
 497         def calculate (self):
 498
 499                 # do grace notes.
 500                 lastch = None
 501                 in_grace = 0
 502                 for c in self.chords:
 503                         if c.grace and (lastch == None or (not lastch.grace)):
 504                                 c.chord_prefix = r'\grace {' + c.chord_prefix
 505                                 in_grace = 1
 506                         elif not c.grace and lastch and lastch.grace:
 507                                 lastch.chord_suffix = lastch.chord_suffix + ' } '
 508                                 in_grace = 0
 509
 510                         lastch = c
 511
 512                 if lastch and in_grace:
 513                         lastch.chord_suffix += '}'
 514
 515
 516         def dump (self):
 517                 str = '%% FR(%d)\n' % self.number
 518                 left = self.measure.global_measure.length ()
 519
 520
 521                 ln = ''
 522                 for c in self.chords:
 523                         add = c.ly_string () + ' '
 524                         if len (ln) + len(add) > 72:
 525                                 str = str + ln + '\n'
 526                                 ln = ''
 527                         ln = ln + add
 528                         left = rat_subtract (left, c.length ())
 529
 530                 str = str + ln
 531
 532                 if left[0] < 0:
 533                         sys.stderr.write ("""\nHuh? Going backwards in frame no %d, start/end (%d,%d)""" % (self.number, self.start, self.end))
 534                         left = (0,1)
 535                 if left[0]:
 536                         str = str + rational_to_lily_skip (left)
 537
 538                 str = str + '  | \n'
 539                 return str
 540
 541 def encodeint (i):
 542         return chr ( i  + ord ('A'))
 543
 544 class Staff:
 545         def __init__ (self, number):
 546                 self.number = number
 547                 self.measures = []
 548
 549         def get_measure (self, no):
 550                 fill_list_to (self.measures, no)
 551
 552                 if self.measures[no] == None:
 553                         m = Measure (no)
 554                         self.measures [no] =m
 555                         m.staff = self
 556
 557                 return self.measures[no]
 558         def staffid (self):
 559                 return 'staff' + encodeint (self.number - 1)
 560         def layerid (self, l):
 561                 return self.staffid() +  'layer%s' % chr (l -1 + ord ('A'))
 562
 563         def dump_time_key_sigs (self):
 564                 k  = ''
 565                 last_key = None
 566                 last_time = None
 567                 last_clef = None
 568                 gap = (0,1)
 569                 for m in self.measures[1:]:
 570                         if not m or not m.valid:
 571                                 continue # ugh.
 572
 573                         g = m.global_measure
 574                         e = ''
 575
 576                         if g:
 577                                 if g.key_signature and not g.key_signature.equal(last_key):
 578                                         pitch= g.key_signature.pitch
 579                                         e = e + "\\key %s %s " % (lily_notename (pitch),
 580                                                                   g.key_signature.signature_type())
 581
 582                                         last_key = g.key_signature
 583                                 if last_time <> g.timesig :
 584                                         e = e + "\\time %d/%d " % g.timesig
 585                                         last_time = g.timesig
 586
 587                                 if 'start' in g.repeats:
 588                                         e = e + ' \\bar "|:" '
 589
 590
 591                                 # we don't attempt voltas since they fail easily.
 592                                 if 0 : # and g.repeat_bar == '|:' or g.repeat_bar == ':|:' or g.bracket:
 593                                         strs = []
 594                                         if g.repeat_bar == '|:' or g.repeat_bar == ':|:' or g.bracket == 'end':
 595                                                 strs.append ('#f')
 596
 597
 598                                         if g.bracket == 'start':
 599                                                 strs.append ('"0."')
 600
 601                                         str = string.join (map (lambda x: '(volta %s)' % x, strs))
 602
 603                                         e = e + ' \\set Score.repeatCommands =  #\'(%s) ' % str
 604
 605                                 if g.force_break:
 606                                         e = e + ' \\break '
 607
 608                         if last_clef <> m.clef :
 609                                 e = e + '\\clef "%s"' % lily_clef (m.clef)
 610                                 last_clef = m.clef
 611                         if e:
 612                                 if gap <> (0,1):
 613                                         k = k +' ' + rational_to_lily_skip (gap) + '\n'
 614                                 gap = (0,1)
 615                                 k = k + e
 616
 617                         if g:
 618                                 gap = rat_add (gap, g.length ())
 619                                 if 'stop' in g.repeats:
 620                                         k = k + ' \\bar ":|" '
 621
 622                 k = '%sglobal = { %s }\n\n ' % (self.staffid (), k)
 623                 return k
 624
 625         def dump (self):
 626                 str = ''
 627
 628
 629                 layerids = []
 630                 for x in range (1,5): # 4 layers.
 631                         laystr =  ''
 632                         last_frame = None
 633                         first_frame = None
 634                         gap = (0,1)
 635                         for m in self.measures[1:]:
 636                                 if not m or not m.valid:
 637                                         sys.stderr.write ("Skipping non-existant or invalid measure\n")
 638                                         continue
 639
 640                                 fr = None
 641                                 try:
 642                                         fr = m.frames[x]
 643                                 except IndexError:
 644                                         sys.stderr.write ("Skipping nonexistent frame %d\n" % x)
 645                                         laystr = laystr + "%% non existent frame %d (skipped) \n" % x
 646                                 if fr:
 647                                         first_frame = fr
 648                                         if gap <> (0,1):
 649                                                 laystr = laystr +'} %s {\n ' % rational_to_lily_skip (gap)
 650                                                 gap = (0,1)
 651                                         laystr = laystr + fr.dump ()
 652                                 else:
 653                                         if m.global_measure :
 654                                                 gap = rat_add (gap, m.global_measure.length ())
 655                                         else:
 656                                                 sys.stderr.write ( \
 657                                                         "No global measure for staff %d measure %d\n"
 658                                                         % (self.number, m.number))
 659                         if first_frame:
 660                                 l = self.layerid (x)
 661                                 laystr = '%s = { {  %s } }\n\n' % (l, laystr)
 662                                 str = str  + laystr
 663                                 layerids.append (l)
 664
 665                 str = str +  self.dump_time_key_sigs ()
 666                 stafdef = '\\%sglobal' % self.staffid ()
 667                 for i in layerids:
 668                         stafdef = stafdef + ' \\' + i
 669
 670
 671                 str = str + '%s = \\context Staff = %s <<\n %s\n >>\n' % \
 672                       (self.staffid (), self.staffid (), stafdef)
 673                 return str
 674
 675
 676
 677 def ziplist (l):
 678         if len (l) < 2:
 679                 return []
 680         else:
 681                 return [(l[0], l[1])] + ziplist (l[2:])
 682
 683
 684 class Chord:
 685         def __init__ (self, number, contents):
 686                 self.pitches = []
 687                 self.frame = None
 688                 self.finale = contents[:7]
 689
 690                 self.notelist = ziplist (contents[7:])
 691                 self.duration  = None
 692                 self.next = None
 693                 self.prev = None
 694                 self.number = number
 695                 self.note_prefix= ''
 696                 self.note_suffix = ''
 697                 self.chord_suffix = ''
 698                 self.chord_prefix = ''
 699                 self.tuplet = None
 700                 self.grace = 0
 701
 702         def measure (self):
 703                 if not self.frame:
 704                         return None
 705                 return self.frame.measure
 706
 707         def length (self):
 708                 if self.grace:
 709                         return (0,1)
 710
 711                 l = (1, self.duration[0])
 712
 713                 d = 1 << self.duration[1]
 714
 715                 dotfact = rat_subtract ((2,1), (1,d))
 716                 mylen =  rat_multiply (dotfact, l)
 717
 718                 if self.tuplet:
 719                         mylen = rat_multiply (mylen, self.tuplet.factor())
 720                 return mylen
 721
 722
 723         def EDU_duration (self):
 724                 return self.finale[2]
 725         def set_duration (self):
 726                 self.duration = EDU_to_duration(self.EDU_duration ())
 727
 728         def calculate (self):
 729                 self.find_realpitch ()
 730                 self.set_duration ()
 731
 732                 flag = self.finale[4]
 733                 if Chord.GRACE_MASK & flag:
 734                         self.grace = 1
 735
 736
 737         def find_realpitch (self):
 738
 739                 meas = self.measure ()
 740                 tiestart = 0
 741                 if not meas or not meas.global_measure  :
 742                         sys.stderr.write ('note %d not in measure\n' % self.number)
 743                 elif not meas.global_measure.scale:
 744                         sys.stderr.write ('note %d: no scale in this measure.' % self.number)
 745                 else:
 746
 747                         for p in self.notelist:
 748                                 (pitch, flag) = p
 749
 750
 751                                 nib1 = pitch & 0x0f
 752
 753                                 if nib1 > 8:
 754                                         nib1 = -(nib1 - 8)
 755                                 rest = pitch / 16
 756
 757                                 scale =  meas.global_measure.scale
 758                                 (sn, sa) =scale[rest % 7]
 759                                 sn = sn + (rest - (rest%7)) + 7
 760                                 acc = sa + nib1
 761                                 self.pitches.append ((sn, acc))
 762                                 tiestart =  tiestart or (flag & Chord.TIE_START_MASK)
 763                 if tiestart :
 764                         self.chord_suffix = self.chord_suffix + ' ~ '
 765
 766         REST_MASK = 0x40000000L
 767         TIE_START_MASK = 0x40000000L
 768         GRACE_MASK = 0x00800000L
 769
 770         def ly_string (self):
 771                 s = ''
 772
 773                 rest = ''
 774
 775
 776                 if not (self.finale[4] & Chord.REST_MASK):
 777                         rest = 'r'
 778
 779                 for p in self.pitches:
 780                         (n,a) =  p
 781                         o = n/ 7
 782                         n = n % 7
 783
 784                         nn = lily_notename ((n,a))
 785
 786                         if o < 0:
 787                                 nn = nn + (',' * -o)
 788                         elif o > 0:
 789                                 nn = nn + ('\'' * o)
 790
 791                         if s:
 792                                 s = s + ' '
 793
 794                         if rest:
 795                                 nn = rest
 796
 797                         s = s + nn
 798
 799                 if not self.pitches:
 800                         s  = 'r'
 801                 if len (self.pitches) > 1:
 802                         s = '<%s>' % s
 803
 804                 s = s + '%d%s' % (self.duration[0], '.'* self.duration[1])
 805                 s = self.note_prefix + s + self.note_suffix
 806
 807                 s = self.chord_prefix + s + self.chord_suffix
 808
 809                 return s
 810
 811
 812 def fill_list_to (list, no):
 813         """
 814 Add None to LIST until it contains entry number NO.
 815         """
 816         while len (list) <= no:
 817                 list.extend ([None] * (no - len(list) + 1))
 818         return list
 819
 820 def read_finale_value (str):
 821         """
 822 Pry off one value from STR. The value may be $hex, decimal, or "string".
 823 Return: (value, rest-of-STR)
 824         """
 825         while str and str[0] in ' \t\n':
 826                 str = str[1:]
 827
 828         if not str:
 829                 return (None,str)
 830
 831         if str[0] == '$':
 832                 str = str [1:]
 833
 834                 hex = ''
 835                 while str and str[0] in '0123456789ABCDEF':
 836                         hex = hex  + str[0]
 837                         str = str[1:]
 838
 839
 840                 return (string.atol (hex, 16), str)
 841         elif str[0] == '"':
 842                 str = str[1:]
 843                 s = ''
 844                 while str and str[0] <> '"':
 845                         s = s + str[0]
 846                         str = str[1:]
 847
 848                 return (s,str)
 849         elif str[0] in '-0123456789':
 850                 dec = ''
 851                 while str and str[0] in '-0123456789':
 852                         dec = dec  + str[0]
 853                         str = str[1:]
 854
 855                 return (string.atoi (dec), str)
 856         else:
 857                 sys.stderr.write ("can't convert `%s'\n" % str)
 858                 return (None, str)
 859
 860
 861
 862
 863 def parse_etf_file (fn, tag_dict):
 864
 865         """ Read FN, putting ETF info into
 866         a giant dictionary.  The keys of TAG_DICT indicate which tags
 867         to put into the dict.
 868         """
 869
 870         sys.stderr.write ('parsing ... ' )
 871         f = open (fn)
 872
 873         gulp = re.sub ('[\n\r]+', '\n',  f.read ())
 874         ls = string.split (gulp, '\n^')
 875
 876         etf_file_dict = {}
 877         for k in tag_dict.keys ():
 878                 etf_file_dict[k] = {}
 879
 880         last_tag = None
 881         last_numbers = None
 882
 883
 884         for l in  ls:
 885                 m = re.match ('^([a-zA-Z0-9&]+)\(([^)]+)\)', l)
 886                 if m and tag_dict.has_key (m.group (1)):
 887                         tag = m.group (1)
 888
 889                         indices = tuple (map (string.atoi, string.split (m.group (2), ',')))
 890                         content = l[m.end (2)+1:]
 891
 892
 893                         tdict = etf_file_dict[tag]
 894                         if not tdict.has_key (indices):
 895                                 tdict[indices] = []
 896
 897
 898                         parsed = []
 899
 900                         if tag == 'verse' or tag == 'block':
 901                                 m2 = re.match ('(.*)\^end', content)
 902                                 if m2:
 903                                         parsed = [m2.group (1)]
 904                         else:
 905                                 while content:
 906                                         (v, content) = read_finale_value (content)
 907                                         if v <> None:
 908                                                 parsed.append (v)
 909
 910                         tdict [indices].extend (parsed)
 911
 912                         last_indices = indices
 913                         last_tag = tag
 914
 915                         continue
 916
 917 # let's not do this: this really confuses when eE happens to be before  a ^text.
 918 #               if last_tag and last_indices:
 919 #                       etf_file_dict[last_tag][last_indices].append (l)
 920
 921         sys.stderr.write ('\n')
 922         return etf_file_dict
 923
 924
 925
 926
 927
 928 class Etf_file:
 929         def __init__ (self, name):
 930                 self.measures = [None]
 931                 self.chords = [None]
 932                 self.frames = [None]
 933                 self.tuplets = [None]
 934                 self.staffs = [None]
 935                 self.slurs = [None]
 936                 self.articulations = [None]
 937                 self.syllables = [None]
 938                 self.verses = [None]
 939                 self.articulation_defs = [None]
 940
 941                 ## do it
 942                 self.parse (name)
 943
 944         def get_global_measure (self, no):
 945                 fill_list_to (self.measures, no)
 946                 if self.measures[no] == None:
 947                         self.measures [no] = Global_measure (no)
 948
 949                 return self.measures[no]
 950
 951
 952         def get_staff(self,staffno):
 953                 fill_list_to (self.staffs, staffno)
 954                 if self.staffs[staffno] == None:
 955                         self.staffs[staffno] = Staff (staffno)
 956
 957                 return self.staffs[staffno]
 958
 959         # staff-spec
 960         def try_IS (self, indices, contents):
 961                 pass
 962
 963         def try_BC (self, indices, contents):
 964                 bn = indices[0]
 965                 where = contents[0] / 1024.0
 966         def try_TP(self,  indices, contents):
 967                 (nil, num) = indices
 968
 969                 if self.tuplets[-1] == None or num <> self.tuplets[-1].start_note:
 970                         self.tuplets.append (Tuplet (num))
 971
 972                 self.tuplets[-1].append_finale (contents)
 973
 974         def try_IM (self, indices, contents):
 975                 (a,b) = indices
 976                 fin = contents
 977                 self.articulations.append (Articulation (a,b,fin))
 978         def try_verse (self, indices, contents):
 979                 a = indices[0]
 980                 body = contents[0]
 981
 982                 body = re.sub (r"""\^[a-z]+\([^)]+\)""", "", body)
 983                 body = re.sub ("\^[a-z]+", "", body)
 984                 self.verses.append (Verse (a, body))
 985         def try_ve (self,indices, contents):
 986                 (a,b) = indices
 987                 self.syllables.append (Syllable (a,b,contents))
 988
 989         def try_eE (self,indices, contents):
 990                 no = indices[0]
 991                 (prev, next, dur, pos, entryflag, extended, follow) = contents[:7]
 992
 993                 fill_list_to (self.chords, no)
 994                 self.chords[no]  =Chord (no, contents)
 995
 996         def try_Sx(self,indices, contents):
 997                 slurno = indices[0]
 998                 fill_list_to (self.slurs, slurno)
 999                 self.slurs[slurno] = Slur(slurno, contents)
1000
1001         def try_IX (self, indices, contents):
1002                 n = indices[0]
1003                 a = contents[0]
1004                 b = contents[1]
1005
1006                 ix= None
1007                 try:
1008                         ix = self.articulation_defs[n]
1009                 except IndexError:
1010                         ix = Articulation_def (n,a,b)
1011                         self.articulation_defs.append (Articulation_def (n, a, b))
1012
1013         def try_GF(self, indices, contents):
1014                 (staffno,measno) = indices
1015
1016                 st = self.get_staff (staffno)
1017                 meas = st.get_measure (measno)
1018                 meas.finale = contents
1019
1020         def try_FR(self, indices, contents):
1021                 frameno = indices [0]
1022
1023                 startnote = contents[0]
1024                 endnote = contents[1]
1025
1026                 fill_list_to (self.frames, frameno)
1027
1028                 self.frames[frameno] = Frame ((frameno, startnote, endnote))
1029
1030         def try_MS (self, indices, contents):
1031                 measno = indices[0]
1032                 keynum = contents[1]
1033                 meas =self. get_global_measure (measno)
1034
1035                 meas.set_key_sig (keynum)
1036
1037                 beats = contents[2]
1038                 beatlen = contents[3]
1039                 meas.set_timesig ((beats, beatlen))
1040
1041                 meas_flag1 = contents[4]
1042                 meas_flag2 = contents[5]
1043
1044                 meas.set_flags (meas_flag1, meas_flag2);
1045
1046
1047         routine_dict = {
1048                 'MS': try_MS,
1049                 'FR': try_FR,
1050                 'GF': try_GF,
1051                 'IX': try_IX,
1052                 'Sx' : try_Sx,
1053                 'eE' : try_eE,
1054                 'verse' : try_verse,
1055                 've' : try_ve,
1056                 'IM' : try_IM,
1057                 'TP' : try_TP,
1058                 'BC' : try_BC,
1059                 'IS' : try_IS,
1060                 }
1061
1062         def parse (self, etf_dict):
1063                 sys.stderr.write ('reconstructing ...')
1064                 sys.stderr.flush ()
1065
1066                 for (tag,routine) in Etf_file.routine_dict.items ():
1067                         ks = etf_dict[tag].keys ()
1068                         ks.sort ()
1069                         for k in ks:
1070                                 routine (self, k, etf_dict[tag][k])
1071
1072                 sys.stderr.write ('processing ...')
1073                 sys.stderr.flush ()
1074
1075                 self.unthread_entries ()
1076
1077                 for st in self.staffs[1:]:
1078                         if not st:
1079                                 continue
1080                         mno = 1
1081                         for m in st.measures[1:]:
1082                                 if not m:
1083                                         continue
1084
1085                                 m.calculate()
1086                                 try:
1087                                         m.global_measure = self.measures[mno]
1088                                 except IndexError:
1089                                         sys.stderr.write ("Non-existent global measure %d" % mno)
1090                                         continue
1091
1092                                 frame_obj_list = [None]
1093                                 for frno in m.frames:
1094                                         try:
1095                                                 fr = self.frames[frno]
1096                                                 frame_obj_list.append (fr)
1097                                         except IndexError:
1098                                                 sys.stderr.write ("\nNon-existent frame %d"  % frno)
1099
1100                                 m.frames = frame_obj_list
1101                                 for fr in frame_obj_list[1:]:
1102                                         if not fr:
1103                                                 continue
1104
1105                                         fr.set_measure (m)
1106
1107                                         fr.chords = self.get_thread (fr.start, fr.end)
1108                                         for c in fr.chords:
1109                                                 c.frame = fr
1110                                 mno = mno + 1
1111
1112                 for c in self.chords[1:]:
1113                         if c:
1114                                 c.calculate()
1115
1116                 for f in self.frames[1:]:
1117                         if f:
1118                                 f.calculate ()
1119
1120                 for t in self.tuplets[1:]:
1121                         t.calculate (self.chords)
1122
1123                 for s in self.slurs[1:]:
1124                         if s:
1125                                 s.calculate (self.chords)
1126
1127                 for s in self.articulations[1:]:
1128                         s.calculate (self.chords, self.articulation_defs)
1129
1130         def get_thread (self, startno, endno):
1131
1132                 thread = []
1133
1134                 c = None
1135                 try:
1136                         c = self.chords[startno]
1137                 except IndexError:
1138                         sys.stderr.write ("Huh? Frame has invalid bounds (%d,%d)\n" % (startno, endno))
1139                         return []
1140
1141
1142                 while c and c.number <> endno:
1143                         thread.append (c)
1144                         c = c.next
1145
1146                 if c:
1147                         thread.append (c)
1148
1149                 return thread
1150
1151         def dump (self):
1152                 str = ''
1153                 staffs = []
1154                 for s in self.staffs[1:]:
1155                         if s:
1156                                 str = str + '\n\n' + s.dump ()
1157                                 staffs.append ('\\' + s.staffid ())
1158
1159
1160                 # should use \addlyrics ?
1161
1162                 for v in self.verses[1:]:
1163                         str = str + v.dump()
1164
1165                 if len (self.verses) > 1:
1166                         sys.stderr.write ("\nLyrics found; edit to use \\addlyrics to couple to a staff\n")
1167
1168                 if staffs:
1169                         str += '\\version "2.3.25"\n'
1170                         str = str + '<<\n  %s\n>> } ' % string.join (staffs)
1171
1172                 return str
1173
1174
1175         def __str__ (self):
1176                 return 'ETF FILE %s %s' % (self.measures,  self.entries)
1177
1178         def unthread_entries (self):
1179                 for e in self.chords[1:]:
1180                         if not e:
1181                                 continue
1182
1183                         e.prev = self.chords[e.finale[0]]
1184                         e.next = self.chords[e.finale[1]]
1185
1186 def identify():
1187         sys.stderr.write ("%s from LilyPond %s\n" % (program_name, version))
1188
1189 def warranty ():
1190         identify ()
1191         sys.stdout.write ('''
1192 Copyright (c) %s by
1193
1194   Han-Wen Nienhuys
1195   Jan Nieuwenhuizen
1196
1197 %s
1198 %s
1199 ''' % ( '2001--2006',
1200        _('Distributed under terms of the GNU General Public License.'),
1201        _('It comes with NO WARRANTY.')))
1202
1203
1204
1205 def get_option_parser ():
1206         p = ly.get_option_parser (usage='etf2ly [OPTIONS]... ETF-FILE',
1207                                   version="etf2ly (LilyPond) @TOPLEVEL_VERSION@",
1208                                   description=_("""Enigma Transport Format is a format used by Coda Music Technology's
1209 Finale product. This program will convert a subset of ETF to a
1210 ready-to-use lilypond file."""))
1211         p.add_option ('-o', '--output', help=_("write output to FILE"),
1212                       metavar=_("FILE"),
1213                       action='store')
1214         p.add_option ('-w', '--warranty', help=_ ("show warranty"),
1215                       action='store_true',
1216                       ),
1217
1218         p.add_option_group  ('bugs',
1219                              description='''Report bugs via http://post.gmane.org/post.php'''
1220                              '''?group=gmane.comp.gnu.lilypond.bugs\n''')
1221         return p
1222
1223 def do_options ():
1224         opt_parser = get_option_parser()
1225         (options,args) = opt_parser.parse_args ()
1226         if options.warranty:
1227                 warranty ()
1228                 sys.exit (0)
1229
1230         return (options,args)
1231
1232 (options, files) = do_options()
1233 identify()
1234
1235 out_filename = options.output
1236
1237 e = None
1238 for f in files:
1239         if f == '-':
1240                 f = ''
1241
1242         sys.stderr.write ('Processing `%s\'\n' % f)
1243
1244         dict = parse_etf_file (f, Etf_file.routine_dict)
1245         e = Etf_file(dict)
1246         if not out_filename:
1247                 out_filename = os.path.basename (re.sub ('(?i).etf$', '.ly', f))
1248
1249         if out_filename == f:
1250                 out_filename = os.path.basename (f + '.ly')
1251
1252         sys.stderr.write ('Writing `%s\'' % out_filename)
1253         ly = e.dump()
1254
1255
1256
1257         fo = open (out_filename, 'w')
1258         fo.write ('%% lily was here -- automatically converted by etf2ly from %s\n' % f)
1259         fo.write(ly)
1260         fo.close ()
1261