]> git.donarmstrong.com Git - lilypond.git/blob - scripts/midi2ly.py
Merge branch 'dev/kainhofer' of ssh://kainhofer@git.sv.gnu.org/srv/git/lilypond into...
[lilypond.git] / scripts / midi2ly.py
1 #!@TARGET_PYTHON@
2 #
3 # msdi2ly.py -- LilyPond midi import script
4
5 # source file of the GNU LilyPond music typesetter
6 #
7 # (c) 1998--2007  Han-Wen Nienhuys <hanwen@xs4all.nl>
8 #                 Jan Nieuwenhuizen <janneke@gnu.org>
9
10
11 '''
12 TODO:
13     * test on weird and unquantised midi input (lily-devel)
14     * update doc and manpage
15
16     * simply insert clef changes whenever too many ledger lines
17         [to avoid tex capacity exceeded]
18     * do not ever quant skips
19     * better lyrics handling
20     * [see if it is feasible to] move ly-classes to library for use in
21         other converters, while leaving midi specific stuff here
22 '''
23
24 import os
25 import string
26 import sys
27
28 """
29 @relocate-preamble@
30 """
31
32 import midi
33 import lilylib as ly
34
35 ################################################################
36 ## CONSTANTS
37
38
39 output_name = ''
40 LINE_BELL = 60
41 scale_steps = [0,2,4,5,7,9,11]
42 global_options = None
43
44
45 clocks_per_1 = 1536
46 clocks_per_4 = 0
47
48 time = 0
49 reference_note = 0
50 start_quant_clocks = 0
51
52 duration_quant_clocks = 0
53 allowed_tuplet_clocks = []
54
55
56 ################################################################
57
58 localedir = '@localedir@'
59 try:
60     import gettext
61     gettext.bindtextdomain ('lilypond', localedir)
62     gettext.textdomain ('lilypond')
63     _ = gettext.gettext
64 except:
65     def _ (s):
66         return s
67
68 program_name = sys.argv[0]
69 program_version = '@TOPLEVEL_VERSION@'
70
71 errorport = sys.stderr
72
73 def identify ():
74     sys.stdout.write ('%s (GNU LilyPond) %s\n' % (program_name, program_version))
75
76 def warranty ():
77     identify ()
78     sys.stdout.write ('''
79 Copyright (c) %s by
80
81  Han-Wen Nienhuys
82  Jan Nieuwenhuizen
83
84 %s
85 %s
86 '''  ( '2001--2006',
87    _('Distributed under terms of the GNU General Public License.'),
88    _('It comes with NO WARRANTY.')))
89
90
91 def progress (s):
92     errorport.write (s + '\n')
93
94 def warning (s):
95     progress (_ ("warning: ") + s)
96         
97 def error (s):
98     progress (_ ("error: ") + s)
99     raise _ ("Exiting ... ")
100
101 def system (cmd, ignore_error = 0):
102     return ly.system (cmd, ignore_error=ignore_error)
103
104 def strip_extension (f, ext):
105     (p, e) = os.path.splitext (f)
106     if e == ext:
107         e = ''
108     return p + e
109
110 \f
111
112
113 class Duration:
114     allowed_durs = (1, 2, 4, 8, 16, 32, 64, 128)
115     def __init__ (self, clocks):
116         self.clocks = clocks
117         if clocks <= 0:
118             self.clocks = duration_quant_clocks
119         (self.dur, self.num, self.den) = self.dur_num_den (clocks)
120         
121     def dur_num_den (self, clocks):
122         for i in range (len (allowed_tuplet_clocks)):
123             if clocks == allowed_tuplet_clocks[i]:
124                 return global_options.allowed_tuplets[i]
125
126         dur = 0; num = 1; den = 1;
127         g = gcd (clocks, clocks_per_1)
128         if g:
129             (dur, num) = (clocks_per_1 / g, clocks / g)
130         if not dur in self.allowed_durs:
131             dur = 4; num = clocks; den = clocks_per_4
132         return (dur, num, den)
133
134     def dump (self):
135         if self.den == 1:
136             if self.num == 1:
137                 s = '%d' % self.dur
138             elif self.num == 3 and self.dur != 1:
139                 s = '%d.' % (self.dur / 2)
140             else:
141                 s = '%d*%d' % (self.dur, self.num)
142         else:
143             s = '%d*%d/%d' % (self.dur, self.num, self.den)
144             
145         global reference_note
146         reference_note.duration = self
147
148         return s
149
150     def compare (self, other):
151         return self.clocks - other.clocks
152
153 def sign (x):
154     if x >= 0:
155         return 1
156     else:
157         return -1
158
159 class Note:
160     names = (0, 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 6)
161     alterations = (0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0)
162     alteration_names = ('eses', 'es', '', 'is' , 'isis')
163     def __init__ (self, clocks, pitch, velocity):
164         self.pitch = pitch
165         self.velocity = velocity
166         # hmm
167         self.clocks = clocks
168         self.duration = Duration (clocks)
169         (self.octave, self.notename, self.alteration) = self.o_n_a ()
170
171     def o_n_a (self):
172         # major scale: do-do
173         # minor scale: la-la  (= + 5) '''
174
175         n = self.names[(self.pitch) % 12]
176         a = self.alterations[(self.pitch) % 12]
177
178         if a and global_options.key.flats:
179             a = - self.alterations[(self.pitch) % 12]
180             n = (n - a) % 7
181
182         #  By tradition, all scales now consist of a sequence
183         #  of 7 notes each with a distinct name, from amongst
184         #  a b c d e f g.  But, minor scales have a wide
185         #  second interval at the top - the 'leading note' is
186         #  sharped. (Why? it just works that way! Anything
187         #  else doesn't sound as good and isn't as flexible at
188         #  saying things. In medieval times, scales only had 6
189         #  notes to avoid this problem - the hexachords.)
190
191         #  So, the d minor scale is d e f g a b-flat c-sharp d
192         #  - using d-flat for the leading note would skip the
193         #  name c and duplicate the name d.  Why isn't c-sharp
194         #  put in the key signature? Tradition. (It's also
195         #  supposedly based on the Pythagorean theory of the
196         #  cycle of fifths, but that really only applies to
197         #  major scales...)  Anyway, g minor is g a b-flat c d
198         #  e-flat f-sharp g, and all the other flat minor keys
199         #  end up with a natural leading note. And there you
200         #  have it.
201
202         #  John Sankey <bf250@freenet.carleton.ca>
203         #
204         #  Let's also do a-minor: a b c d e f gis a
205         #
206         #  --jcn
207
208         o = self.pitch / 12 - 4
209
210         key = global_options.key
211         if key.minor:
212             # as -> gis
213             if (key.sharps == 0 and key.flats == 0
214                 and n == 5 and a == -1):
215                 n = 4; a = 1
216             # des -> cis
217             elif key.flats == 1 and n == 1 and a == -1:
218                 n = 0; a = 1
219             # ges -> fis
220             elif key.flats == 2 and n == 4 and a == -1:
221                 n = 3; a = 1
222             # g -> fisis
223             elif key.sharps == 5 and n == 4 and a == 0:
224                 n = 3; a = 2
225             # d -> cisis
226             elif key.sharps == 6 and n == 1 and a == 0:
227                 n = 0; a = 2
228             # a -> gisis
229             elif key.sharps == 7 and n == 5 and a == 0:
230                 n = 4; a = 2
231
232         # b -> ces
233         if key.flats >= 6 and n == 6 and a == 0:
234             n = 0; a = -1; o = o + 1
235         # e -> fes
236         if key.flats >= 7 and n == 2 and a == 0:
237             n = 3; a = -1
238
239         # f -> eis
240         if key.sharps >= 3 and n == 3 and a == 0:
241             n = 2; a = 1
242         # c -> bis
243         if key.sharps >= 4 and n == 0 and a == 0:
244             n = 6; a = 1; o = o - 1
245
246         return (o, n, a)
247         
248     def __repr__ (self):
249         s = chr ((self.notename + 2)  % 7 + ord ('a'))
250         return 'Note(%s %s)' % (s, self.duration.dump())
251
252     def dump (self, dump_dur = 1):
253         global reference_note
254         s = chr ((self.notename + 2)  % 7 + ord ('a'))
255         s = s + self.alteration_names[self.alteration + 2]
256         if global_options.absolute_pitches:
257             commas = self.octave
258         else:
259             delta = self.pitch - reference_note.pitch
260             commas = sign (delta) * (abs (delta) / 12)
261             if ((sign (delta) \
262               * (self.notename - reference_note.notename) + 7) \
263               % 7 >= 4) \
264               or ((self.notename == reference_note.notename) \
265                 and (abs (delta) > 4) and (abs (delta) < 12)):
266                 commas = commas + sign (delta)
267             
268         if commas > 0:
269             s = s + "'" * commas
270         elif commas < 0:
271             s = s + "," * -commas
272
273         ## FIXME: compile fix --jcn
274         if dump_dur and (global_options.explicit_durations \
275          or self.duration.compare (reference_note.duration)):
276             s = s + self.duration.dump ()
277
278         reference_note = self
279         
280         # TODO: move space
281         return s + ' '
282
283
284 class Time:
285     def __init__ (self, num, den):
286         self.clocks = 0
287         self.num = num
288         self.den = den
289
290     def bar_clocks (self):
291         return clocks_per_1 * self.num / self.den
292
293     def __repr__ (self):
294         return 'Time(%d/%d)' % (self.num, self.den)
295     
296     def dump (self):
297         global time
298         time = self
299         return '\n  ' + '\\time %d/%d ' % (self.num, self.den) + '\n  '
300
301 class Tempo:
302     def __init__ (self, seconds_per_1):
303         self.clocks = 0
304         self.seconds_per_1 = seconds_per_1
305
306     def __repr__ (self):
307         return 'Tempo(%d)' % self.bpm ()
308     
309     def bpm (self):
310         return 4 * 60 / self.seconds_per_1
311     
312     def dump (self):
313         return '\n  ' + '\\tempo 4 = %d ' % (self.bpm()) + '\n  '
314
315 class Clef:
316     clefs = ('"bass_8"', 'bass', 'violin', '"violin^8"')
317     def __init__ (self, type):
318         self.type = type
319
320     def __repr__ (self):
321         return 'Clef(%s)' % self.clefs[self.type]
322     
323     def dump (self):
324         return '\n  \\clef %s\n  ' % self.clefs[self.type]
325
326 class Key:
327     key_sharps = ('c', 'g', 'd', 'a', 'e', 'b', 'fis')
328     key_flats = ('BUG', 'f', 'bes', 'es', 'as', 'des', 'ges')
329
330     def __init__ (self, sharps, flats, minor):
331         self.clocks = 0
332         self.flats = flats
333         self.sharps = sharps
334         self.minor = minor
335
336     def dump (self):
337         global_options.key = self
338
339         s = ''
340         if self.sharps and self.flats:
341             pass
342         else:
343             if self.flats:
344                 k = (ord ('cfbeadg'[self.flats % 7]) - ord ('a') - 2 -2 * self.minor + 7) % 7
345             else:
346                 k = (ord ('cgdaebf'[self.sharps % 7]) - ord ('a') - 2 -2 * self.minor + 7) % 7
347  
348             if not self.minor:
349                 name = chr ((k + 2) % 7 + ord ('a'))
350             else:
351                 name = chr ((k + 2) % 7 + ord ('a'))
352
353             # fis cis gis dis ais eis bis
354             sharps = (2, 4, 6, 1, 3, 5, 7)
355             # bes es as des ges ces fes
356             flats = (6, 4, 2, 7, 5, 3, 1)
357             a = 0
358             if self.flats:
359                 if flats[k] <= self.flats:
360                     a = -1
361             else:
362                 if sharps[k] <= self.sharps:
363                     a = 1
364
365             if a:
366                 name = name + Note.alteration_names[a + 2]
367
368             s = '\\key ' + name
369             if self.minor:
370                 s = s + ' \\minor'
371             else:
372                 s = s + ' \\major'
373
374         return '\n\n  ' + s + '\n  '
375
376
377 class Text:
378     text_types = (
379         'SEQUENCE_NUMBER',
380         'TEXT_EVENT',
381         'COPYRIGHT_NOTICE',
382         'SEQUENCE_TRACK_NAME',
383         'INSTRUMENT_NAME',
384         'LYRIC',
385         'MARKER',
386         'CUE_POINT',)
387     
388     def __init__ (self, type, text):
389         self.clocks = 0
390         self.type = type
391         self.text = text
392
393     def dump (self):
394         # urg, we should be sure that we're in a lyrics staff
395         if self.type == midi.LYRIC:
396             s = '"%s"' % self.text
397             d = Duration (self.clocks)
398             if global_options.explicit_durations \
399              or d.compare (reference_note.duration):
400                 s = s + Duration (self.clocks).dump ()
401             s = s + ' '
402         else:
403             s = '\n  % [' + self.text_types[self.type] + '] ' + self.text + '\n  '
404         return s
405
406     def __repr__ (self):
407         return 'Text(%d=%s)' % (self.type, self.text)
408
409
410
411 def split_track (track):
412     chs = {}
413     for i in range(16):
414         chs[i] = []
415         
416     for e in track:
417         data = list (e[1])
418         if data[0] > 0x7f and data[0] < 0xf0:
419             c = data[0] & 0x0f
420             e = (e[0], tuple ([data[0] & 0xf0] + data[1:]))
421             chs[c].append (e)
422         else:
423             chs[0].append (e)
424
425     for i in range (16):
426         if chs[i] == []:
427             del chs[i]
428
429     threads = []
430     for v in chs.values ():
431         events = events_on_channel (v)
432         thread = unthread_notes (events)
433         if len (thread):
434             threads.append (thread)
435     return threads
436
437
438 def quantise_clocks (clocks, quant):
439     q = int (clocks / quant) * quant
440     if q != clocks:
441         for tquant in allowed_tuplet_clocks:
442             if int (clocks / tquant) * tquant == clocks:
443                 return clocks
444         if 2 * (clocks - q) > quant:
445             q = q + quant
446     return q
447
448 def end_note (pitches, notes, t, e):
449     try:
450         (lt, vel) = pitches[e]
451         del pitches[e]
452
453         i = len (notes) - 1 
454         while i > 0:
455             if notes[i][0] > lt:
456                 i = i -1
457             else:
458                 break
459         d = t - lt
460         if duration_quant_clocks:
461             d = quantise_clocks (d, duration_quant_clocks)
462             if not d:
463                 d = duration_quant_clocks
464
465         notes.insert (i + 1,
466               (lt, Note (d, e, vel)))
467
468     except KeyError:
469         pass
470
471 def events_on_channel (channel):
472     pitches = {}
473
474     notes = []
475     events = []
476     last_lyric = 0
477     last_time = 0
478     for e in channel:
479         t = e[0]
480
481         if start_quant_clocks:
482             t = quantise_clocks (t, start_quant_clocks)
483
484
485         if e[1][0] == midi.NOTE_OFF \
486          or (e[1][0] == midi.NOTE_ON and e[1][2] == 0):
487             end_note (pitches, notes, t, e[1][1])
488             
489         elif e[1][0] == midi.NOTE_ON:
490             if not pitches.has_key (e[1][1]):
491                 pitches[e[1][1]] = (t, e[1][2])
492                 
493         # all include ALL_NOTES_OFF
494         elif e[1][0] >= midi.ALL_SOUND_OFF \
495           and e[1][0] <= midi.POLY_MODE_ON:
496             for i in pitches.keys ():
497                 end_note (pitches, notes, t, i)
498                 
499         elif e[1][0] == midi.META_EVENT:
500             if e[1][1] == midi.END_OF_TRACK:
501                 for i in pitches.keys ():
502                     end_note (pitches, notes, t, i)
503                 break
504
505             elif e[1][1] == midi.SET_TEMPO:
506                 (u0, u1, u2) = map (ord, e[1][2])
507                 us_per_4 = u2 + 256 * (u1 + 256 * u0)
508                 seconds_per_1 = us_per_4 * 4 / 1e6
509                 events.append ((t, Tempo (seconds_per_1)))
510             elif e[1][1] == midi.TIME_SIGNATURE:
511                 (num, dur, clocks4, count32) = map (ord, e[1][2])
512                 den = 2 ** dur 
513                 events.append ((t, Time (num, den)))
514             elif e[1][1] == midi.KEY_SIGNATURE:
515                 (alterations, minor) = map (ord, e[1][2])
516                 sharps = 0
517                 flats = 0
518                 if alterations < 127:
519                     sharps = alterations
520                 else:
521                     flats = 256 - alterations
522
523                 k = Key (sharps, flats, minor)
524                 events.append ((t, k))
525
526                 # ugh, must set key while parsing
527                 # because Note init uses key
528                 # Better do Note.calc () at dump time?
529                 global_options.key = k
530
531             elif e[1][1] == midi.LYRIC \
532               or (global_options.text_lyrics and e[1][1] == midi.TEXT_EVENT):
533                 if last_lyric:
534                     last_lyric.clocks = t - last_time
535                     events.append ((last_time, last_lyric))
536                 last_time = t
537                 last_lyric = Text (midi.LYRIC, e[1][2])
538
539             elif e[1][1] >= midi.SEQUENCE_NUMBER \
540               and e[1][1] <= midi.CUE_POINT:
541                 events.append ((t, Text (e[1][1], e[1][2])))
542             else:
543                 if global_options.verbose:
544                     sys.stderr.write ("SKIP: %s\n" % `e`)
545                 pass
546         else:
547             if global_options.verbose:
548                 sys.stderr.write ("SKIP: %s\n" % `e`)
549             pass
550
551     if last_lyric:
552         # last_lyric.clocks = t - last_time
553         # hmm
554         last_lyric.clocks = clocks_per_4
555         events.append ((last_time, last_lyric))
556         last_lyric = 0
557         
558     i = 0
559     while len (notes):
560         if i < len (events) and notes[0][0] >= events[i][0]:
561             i = i + 1
562         else:
563             events.insert (i, notes[0])
564             del notes[0]
565     return events
566
567 def unthread_notes (channel):
568     threads = []
569     while channel:
570         thread = []
571         end_busy_t = 0
572         start_busy_t = 0
573         todo = []
574         for e in channel:
575             t = e[0]
576             if e[1].__class__ == Note \
577              and ((t == start_busy_t \
578                 and e[1].clocks + t == end_busy_t) \
579               or t >= end_busy_t):
580                 thread.append (e)
581                 start_busy_t = t
582                 end_busy_t = t + e[1].clocks
583             elif e[1].__class__ == Time \
584               or e[1].__class__ == Key \
585               or e[1].__class__ == Text \
586               or e[1].__class__ == Tempo:
587                 thread.append (e)
588             else:
589                 todo.append (e)
590         threads.append (thread)
591         channel = todo
592
593     return threads
594
595 def gcd (a,b):
596     if b == 0:
597         return a
598     c = a
599     while c: 
600         c = a % b
601         a = b
602         b = c
603     return a
604     
605 def dump_skip (skip, clocks):
606     return skip + Duration (clocks).dump () + ' '
607
608 def dump (d):
609     return d.dump ()
610
611 def dump_chord (ch):
612     s = ''
613     notes = []
614     for i in ch:
615         if i.__class__ == Note:
616             notes.append (i)
617         else:
618             s = s + i.dump ()
619     if len (notes) == 1:
620         s = s + dump (notes[0])
621     elif len (notes) > 1:
622         global reference_note
623         s = s + '<'
624         s = s + notes[0].dump (dump_dur = 0)
625         r = reference_note
626         for i in notes[1:]:
627             s = s + i.dump (dump_dur = 0 )
628         s = s + '>'
629
630         s = s + notes[0].duration.dump() + ' '
631         reference_note = r
632     return s
633
634 def dump_bar_line (last_bar_t, t, bar_count):
635     s = ''
636     bar_t = time.bar_clocks ()
637     if t - last_bar_t >= bar_t:
638         bar_count = bar_count + (t - last_bar_t) / bar_t
639         
640         if t - last_bar_t == bar_t:
641             s = '|\n  %% %d\n  ' % bar_count
642             last_bar_t = t
643         else:
644             # urg, this will barf at meter changes
645             last_bar_t = last_bar_t + (t - last_bar_t) / bar_t * bar_t
646             
647     return (s, last_bar_t, bar_count)
648
649             
650 def dump_channel (thread, skip):
651     global reference_note, time
652
653     global_options.key = Key (0, 0, 0)
654     time = Time (4, 4)
655     # urg LilyPond doesn't start at c4, but
656     # remembers from previous tracks!
657     # reference_note = Note (clocks_per_4, 4*12, 0)
658     reference_note = Note (0, 4*12, 0)
659     last_e = None
660     chs = []
661     ch = []
662
663     for e in thread:
664         if last_e and last_e[0] == e[0]:
665             ch.append (e[1])
666         else:
667             if ch:
668                 chs.append ((last_e[0], ch))
669                 
670             ch = [e[1]]
671             
672         last_e = e
673
674     if ch:
675         chs.append ((last_e[0], ch))
676     t = 0
677     last_t = 0
678     last_bar_t = 0
679     bar_count = 1
680     
681     lines = ['']
682     for ch in chs: 
683         t = ch[0]
684
685         i = string.rfind (lines[-1], '\n') + 1
686         if len (lines[-1][i:]) > LINE_BELL:
687             lines.append ('')
688             
689         if t - last_t > 0:
690             lines[-1] = lines[-1] + dump_skip (skip, t-last_t)
691         elif t - last_t < 0:
692             errorport.write ('BUG: time skew')
693
694         (s, last_bar_t, bar_count) = dump_bar_line (last_bar_t,
695                               t, bar_count)
696         lines[-1] = lines[-1] + s
697         
698         lines[-1] = lines[-1] + dump_chord (ch[1])
699
700         clocks = 0
701         for i in ch[1]:
702             if i.clocks > clocks:
703                 clocks = i.clocks
704                 
705         last_t = t + clocks
706         
707         (s, last_bar_t, bar_count) = dump_bar_line (last_bar_t,
708                               last_t, bar_count)
709         lines[-1] = lines[-1] + s
710
711     return string.join (lines, '\n  ') + '\n'
712
713 def track_name (i):
714     return 'track%c' % (i + ord ('A'))
715
716 def channel_name (i):
717     return 'channel%c' % (i + ord ('A'))
718
719 def dump_track (channels, n):
720     s = '\n'
721     track = track_name (n)
722     clef = guess_clef (channels)
723
724     for i in range (len (channels)):
725         channel = channel_name (i)
726         item = thread_first_item (channels[i])
727
728         if item and item.__class__ == Note:
729             skip = 's'
730             s = s + '%s = ' % (track + channel)
731             if not global_options.absolute_pitches:
732                 s = s + '\\relative c '
733         elif item and item.__class__ == Text:
734             skip = '" "'
735             s = s + '%s = \\lyricmode ' % (track + channel)
736         else:
737             skip = '\\skip '
738             s = s + '%s =  ' % (track + channel)
739         s = s + '{\n'
740         s = s + '  ' + dump_channel (channels[i][0], skip)
741         s = s + '}\n\n'
742
743     s = s + '%s = <<\n' % track
744
745     if clef.type != 2:
746         s = s + clef.dump () + '\n'
747
748     for i in range (len (channels)):
749         channel = channel_name (i)
750         item = thread_first_item (channels[i])
751         if item and item.__class__ == Text:
752             s = s + '  \\context Lyrics = %s \\%s\n' % (channel,
753                                   track + channel)
754         else:
755             s = s + '  \\context Voice = %s \\%s\n' % (channel,
756                                  track + channel)
757     s = s + '>>\n\n'
758     return s
759
760 def thread_first_item (thread):
761     for chord in thread:
762         for event in chord:
763             if (event[1].__class__ == Note 
764               or (event[1].__class__ == Text 
765                 and event[1].type == midi.LYRIC)):
766                 
767               return event[1]
768     return None
769
770 def track_first_item (track):
771     for thread in track:
772         first = thread_first_item (thread)
773         if first:
774             return first
775     return None
776
777 def guess_clef (track):
778     i = 0
779     p = 0
780     for thread in track:
781         for chord in thread:
782             for event in chord:
783                 if event[1].__class__ == Note:
784                     i = i + 1
785                     p = p + event[1].pitch
786     if i and p / i <= 3*12:
787         return Clef (0)
788     elif i and p / i <= 5*12:
789         return Clef (1)
790     elif i and p / i >= 7*12:
791         return Clef (3)
792     else:
793         return Clef (2)
794     
795
796 def convert_midi (in_file, out_file):
797     global clocks_per_1, clocks_per_4, key
798     global start_quant_clocks
799     global  duration_quant_clocks
800     global allowed_tuplet_clocks
801
802     str = open (in_file).read ()
803     midi_dump = midi.parse (str)
804     
805     clocks_per_1 = midi_dump[0][1]
806     clocks_per_4 = clocks_per_1 / 4
807     
808     if global_options.start_quant:
809         start_quant_clocks = clocks_per_1 / global_options.start_quant
810
811     if global_options.duration_quant:
812         duration_quant_clocks = clocks_per_1 / global_options.duration_quant
813
814     allowed_tuplet_clocks = []
815     for (dur, num, den) in global_options.allowed_tuplets:
816         allowed_tuplet_clocks.append (clocks_per_1 / den)
817
818     tracks = []
819     for t in midi_dump[1]:
820         global_options.key = Key (0, 0, 0)
821         tracks.append (split_track (t))
822
823     tag = '%% Lily was here -- automatically converted by %s from %s' % ( program_name, in_file)
824
825     
826     s = ''
827     s = tag + '\n\\version "2.7.18"\n\n'
828     for i in range (len (tracks)):
829         s = s + dump_track (tracks[i], i)
830
831     s = s + '\n\\score {\n  <<\n'
832     
833     i = 0
834     for t in tracks:
835         track = track_name (i)
836         item = track_first_item (t)
837         
838         if item and item.__class__ == Note:
839             s = s + '    \\context Staff=%s \\%s\n' % (track, track)
840         elif item and item.__class__ == Text:
841             s = s + '    \\context Lyrics=%s \\%s\n' % (track, track)
842
843         i += 1
844     s = s + '  >>\n}\n'
845
846     progress (_ ("%s output to `%s'...") % ('LY', out_file))
847
848     if out_file == '-':
849         handle = sys.stdout
850     else:
851         handle = open (out_file, 'w')
852
853     handle.write (s)
854     handle.close ()
855
856
857 def get_option_parser ():
858     p = ly.get_option_parser (usage=_ ("%s [OPTION]... FILE") % 'midi2ly',
859                  version="midi2ly (LilyPond) @TOPLEVEL_VERSION@",
860                  description=_ ("Convert %s to LilyPond input.") % 'MIDI')
861
862     p.add_option ('-a', '--absolute-pitches',
863            action='store_true',
864            help=_ ("print absolute pitches"))
865     p.add_option ('-d', '--duration-quant',
866            metavar= _("DUR"),
867            help=_ ("quantise note durations on DUR"))
868     p.add_option ('-e', '--explicit-durations',
869            action='store_true',
870            help=_ ("print explicit durations"))
871     p.add_option('-k', '--key', help=_ ("set key: ALT=+sharps|-flats; MINOR=1"),
872           metavar=_ ("ALT[:MINOR]"),
873           default='0'),
874     p.add_option ('-o', '--output', help=_ ("write output to FILE"),
875            metavar=_("FILE"),
876            action='store')
877     p.add_option ('-s', '--start-quant',help= _ ("quantise note starts on DUR"),
878            metavar=_ ("DUR"))
879     p.add_option ('-t', '--allow-tuplet',
880            metavar=_ ("DUR*NUM/DEN"),
881            action = "append",
882            dest="allowed_tuplets",
883            help=_ ("allow tuplet durations DUR*NUM/DEN"),
884            default=[])
885     p.add_option ('-V', '--verbose', help=_ ("be verbose"),
886            action='store_true'
887            ),
888     p.add_option ('-w', '--warranty', help=_ ("show warranty and copyright"),
889            action='store_true',
890            ),
891     p.add_option ('-x', '--text-lyrics', help=_ ("treat every text as a lyric"),
892            action='store_true')
893
894     p.add_option_group (_ ("Examples"),
895               description = r'''
896   midi2ly --key=-2:1 --duration-quant=32 \
897     --allow-tuplet=4*2/3 --allow-tuplet=2*4/3 foo.midi
898 ''')
899     p.add_option_group ('bugs',
900                         description=(_ ('Report bugs via')
901                                      + ''' http://post.gmane.org/post.php'''
902                                      '''?group=gmane.comp.gnu.lilypond.bugs\n'''))
903     return p
904
905
906
907 def do_options ():
908     opt_parser = get_option_parser()
909     (options, args) = opt_parser.parse_args ()
910
911     if not args or args[0] == '-':
912         opt_parser.print_help ()
913         sys.stderr.write ('\n%s: %s %s\n' % (program_name, _ ("error: "),
914                           _ ("no files specified on command line.")))
915         sys.exit (2)
916
917     if options.duration_quant:
918         options.duration_quant = int (options.duration_quant)
919
920     if options.warranty:
921         warranty ()
922         sys.exit (0)
923     if 1:
924         (alterations, minor) = map (int, string.split (options.key + ':0', ':'))[0:2]
925         sharps = 0
926         flats = 0
927         if alterations >= 0:
928             sharps = alterations
929         else:
930             flats = - alterations
931
932         options.key = Key (sharps, flats, minor)
933
934         
935     if options.start_quant:
936         options.start_quant = int (options.start_quant)
937         
938     options.allowed_tuplets = [map (int, a.replace ('/','*').split ('*'))
939                 for a in options.allowed_tuplets]
940     
941     global global_options
942     global_options = options
943
944     return args
945
946 def main():
947     files = do_options()
948
949     for f in files:
950         g = f
951         g = strip_extension (g, '.midi')
952         g = strip_extension (g, '.mid')
953         g = strip_extension (g, '.MID')
954         (outdir, outbase) = ('','')
955
956         if not output_name:
957             outdir = '.'
958             outbase = os.path.basename (g)
959             o = os.path.join (outdir, outbase + '-midi.ly')
960         elif output_name[-1] == os.sep:
961             outdir = output_name
962             outbase = os.path.basename (g)
963             os.path.join (outdir, outbase + '-gen.ly')
964         else:
965             o = output_name
966             (outdir, outbase) = os.path.split (o)
967
968         if outdir != '.' and outdir != '':
969             try:
970                 os.mkdir (outdir, 0777)
971             except OSError:
972                 pass
973
974         convert_midi (f, o)
975 if __name__ == '__main__':
976     main()