2 # -*- coding: utf-8 -*-
22 from rational
import Rational
24 # Store command-line options in a global variable, so we can access them everythwere
27 class Conversion_Settings
:
29 self
.ignore_beaming
= False
31 conversion_settings
= Conversion_Settings ()
32 # Use a global variable to store the setting needed inside a \layout block.
33 # whenever we need to change a setting or add/remove an engraver, we can access
34 # this layout and add the corresponding settings
35 layout_information
= musicexp
.Layout ()
38 ly
.stderr_write (str + '\n')
41 def error_message (str):
42 ly
.stderr_write (str + '\n')
45 needed_additional_definitions
= []
46 additional_definitions
= {
48 "tuplet-note-wrapper": """ % a formatter function, which is simply a wrapper around an existing
49 % tuplet formatter function. It takes the value returned by the given
50 % function and appends a note of given length.
51 #(define-public ((tuplet-number::append-note-wrapper function note) grob)
52 (let* ((txt (if function (function grob) #f)))
54 (markup txt #:fontsize -5 #:note note UP)
55 (markup #:fontsize -5 #:note note UP)
60 "tuplet-non-default-denominator": """#(define ((tuplet-number::non-default-tuplet-denominator-text denominator) grob)
61 (number->string (if denominator
63 (ly:event-property (event-cause grob) 'denominator))))
66 "tuplet-non-default-fraction": """#(define ((tuplet-number::non-default-tuplet-fraction-text denominator numerator) grob)
67 (let* ((ev (event-cause grob))
68 (den (if denominator denominator (ly:event-property ev 'denominator)))
69 (num (if numerator numerator (ly:event-property ev 'numerator))))
70 (format "~a:~a" den num)))
73 "compound-time-signature": """%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
74 % Formatting of (possibly complex) compound time signatures
75 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
77 #(define-public (insert-markups l m)
78 (let* ((ll (reverse l)))
79 (let join-markups ((markups (list (car ll)))
82 (join-markups (cons (car remaining) (cons m markups)) (cdr remaining))
85 % Use a centered-column inside a left-column, because the centered column
86 % moves its reference point to the center, which the left-column undoes.
87 % The center-column also aligns its contented centered, which is not undone...
88 #(define-public (format-time-fraction time-sig-fraction)
89 (let* ((revargs (reverse (map number->string time-sig-fraction)))
91 (nums (reverse (cdr revargs))))
92 (make-override-markup '(baseline-skip . 0)
94 (make-left-column-markup (list
95 (make-center-column-markup (list
96 (make-line-markup (insert-markups nums "+"))
99 #(define-public (format-complex-compound-time time-sig)
100 (let* ((sigs (map format-time-fraction time-sig)))
101 (make-override-markup '(baseline-skip . 0)
104 (insert-markups sigs (make-vcenter-markup "+")))))))
106 #(define-public (format-compound-time time-sig)
108 ((not (pair? time-sig)) (null-markup))
109 ((pair? (car time-sig)) (format-complex-compound-time time-sig))
110 (else (format-time-fraction time-sig))))
113 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
114 % Measure length calculation of (possibly complex) compound time signatures
115 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
117 #(define-public (calculate-time-fraction time-sig-fraction)
118 (let* ((revargs (reverse time-sig-fraction))
120 (nums (cdr revargs)))
121 (ly:make-moment (apply + nums) den)))
123 #(define-public (calculate-complex-compound-time time-sig)
124 (let* ((sigs (map calculate-time-fraction time-sig)))
125 (let add-moment ((moment ZERO-MOMENT)
127 (if (pair? remaining)
128 (add-moment (ly:moment-add moment (car remaining)) (cdr remaining))
131 #(define-public (calculate-compound-measure-length time-sig)
133 ((not (pair? time-sig)) (ly:make-moment 4 4))
134 ((pair? (car time-sig)) (calculate-complex-compound-time time-sig))
135 (else (calculate-time-fraction time-sig))))
138 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
140 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
142 #(define-public (calculate-compound-base-beat-full time-sig)
143 (let* ((den (map last time-sig)))
146 #(define-public (calculate-compound-base-beat time-sig)
147 (ly:make-moment 1 (cond
148 ((not (pair? time-sig)) 4)
149 ((pair? (car time-sig)) (calculate-compound-base-beat-full time-sig))
150 (else (calculate-compound-base-beat-full (list time-sig))))))
153 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
154 % The music function to set the complex time signature
155 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
158 #(define-music-function (parser location args) (pair?)
159 (let ((mlen (calculate-compound-measure-length args))
160 (beat (calculate-compound-base-beat args)))
162 \once \override Staff.TimeSignature #'stencil = #ly:text-interface::print
163 \once \override Staff.TimeSignature #'text = #(format-compound-time $args)
164 % \set Staff.beatGrouping = #(reverse (cdr (reverse $args)))
165 \set Timing.measureLength = $mlen
166 \set Timing.timeSignatureFraction = #(cons (ly:moment-main-numerator $mlen)
167 (ly:moment-main-denominator $mlen))
168 \set Timing.beatLength = $beat
170 % TODO: Implement beatGrouping and auto-beam-settings!!!
175 def round_to_two_digits (val
):
176 return round (val
* 100) / 100
178 def extract_paper_information (tree
):
179 paper
= musicexp
.Paper ()
180 defaults
= tree
.get_maybe_exist_named_child ('defaults')
184 scaling
= defaults
.get_maybe_exist_named_child ('scaling')
186 mm
= scaling
.get_named_child ('millimeters')
187 mm
= string
.atof (mm
.get_text ())
188 tn
= scaling
.get_maybe_exist_named_child ('tenths')
189 tn
= string
.atof (tn
.get_text ())
191 paper
.global_staff_size
= mm
* 72.27 / 25.4
192 # We need the scaling (i.e. the size of staff tenths for everything!
196 def from_tenths (txt
):
197 return round_to_two_digits (string
.atof (txt
) * tenths
/ 10)
198 def set_paper_variable (varname
, parent
, element_name
):
199 el
= parent
.get_maybe_exist_named_child (element_name
)
200 if el
: # Convert to cm from tenths
201 setattr (paper
, varname
, from_tenths (el
.get_text ()))
203 pagelayout
= defaults
.get_maybe_exist_named_child ('page-layout')
205 # TODO: How can one have different margins for even and odd pages???
206 set_paper_variable ("page_height", pagelayout
, 'page-height')
207 set_paper_variable ("page_width", pagelayout
, 'page-width')
209 pmargins
= pagelayout
.get_named_children ('page-margins')
211 set_paper_variable ("left_margin", pm
, 'left-margin')
212 set_paper_variable ("right_margin", pm
, 'right-margin')
213 set_paper_variable ("bottom_margin", pm
, 'bottom-margin')
214 set_paper_variable ("top_margin", pm
, 'top-margin')
216 systemlayout
= defaults
.get_maybe_exist_named_child ('system-layout')
218 sl
= systemlayout
.get_maybe_exist_named_child ('system-margins')
220 set_paper_variable ("system_left_margin", sl
, 'left-margin')
221 set_paper_variable ("system_right_margin", sl
, 'right-margin')
222 set_paper_variable ("system_distance", systemlayout
, 'system-distance')
223 set_paper_variable ("top_system_distance", systemlayout
, 'top-system-distance')
225 stafflayout
= defaults
.get_named_children ('staff-layout')
226 for sl
in stafflayout
:
227 nr
= getattr (sl
, 'number', 1)
228 dist
= sl
.get_named_child ('staff-distance')
229 #TODO: the staff distance needs to be set in the Staff context!!!
231 # TODO: Finish appearance?, music-font?, word-font?, lyric-font*, lyric-language*
232 appearance
= defaults
.get_named_child ('appearance')
234 lws
= appearance
.get_named_children ('line-width')
236 # Possible types are: beam, bracket, dashes,
237 # enclosure, ending, extend, heavy barline, leger,
238 # light barline, octave shift, pedal, slur middle, slur tip,
239 # staff, stem, tie middle, tie tip, tuplet bracket, and wedge
241 w
= from_tenths (lw
.get_text ())
242 # TODO: Do something with these values!
243 nss
= appearance
.get_named_children ('note-size')
245 # Possible types are: cue, grace and large
247 sz
= from_tenths (ns
.get_text ())
248 # TODO: Do something with these values!
249 # <other-appearance> elements have no specified meaning
251 rawmusicfont
= defaults
.get_named_child ('music-font')
253 # TODO: Convert the font
255 rawwordfont
= defaults
.get_named_child ('word-font')
257 # TODO: Convert the font
259 rawlyricsfonts
= defaults
.get_named_children ('lyric-font')
260 for lyricsfont
in rawlyricsfonts
:
261 # TODO: Convert the font
268 # score information is contained in the <work>, <identification> or <movement-title> tags
269 # extract those into a hash, indexed by proper lilypond header attributes
270 def extract_score_information (tree
):
271 header
= musicexp
.Header ()
272 def set_if_exists (field
, value
):
274 header
.set_field (field
, musicxml
.escape_ly_output_string (value
))
276 work
= tree
.get_maybe_exist_named_child ('work')
278 set_if_exists ('title', work
.get_work_title ())
279 set_if_exists ('worknumber', work
.get_work_number ())
280 set_if_exists ('opus', work
.get_opus ())
282 movement_title
= tree
.get_maybe_exist_named_child ('movement-title')
284 set_if_exists ('title', movement_title
.get_text ())
286 identifications
= tree
.get_named_children ('identification')
287 for ids
in identifications
:
288 set_if_exists ('copyright', ids
.get_rights ())
289 set_if_exists ('composer', ids
.get_composer ())
290 set_if_exists ('arranger', ids
.get_arranger ())
291 set_if_exists ('editor', ids
.get_editor ())
292 set_if_exists ('poet', ids
.get_poet ())
294 set_if_exists ('tagline', ids
.get_encoding_software ())
295 set_if_exists ('encodingsoftware', ids
.get_encoding_software ())
296 set_if_exists ('encodingdate', ids
.get_encoding_date ())
297 set_if_exists ('encoder', ids
.get_encoding_person ())
298 set_if_exists ('encodingdescription', ids
.get_encoding_description ())
300 set_if_exists ('texidoc', ids
.get_file_description ());
302 # Finally, apply the required compatibility modes
303 # Some applications created wrong MusicXML files, so we need to
304 # apply some compatibility mode, e.g. ignoring some features/tags
306 software
= ids
.get_encoding_software_list ()
308 # Case 1: "Sibelius 5.1" with the "Dolet 3.4 for Sibelius" plugin
309 # is missing all beam ends => ignore all beaming information
310 if "Dolet 3.4 for Sibelius" in software
:
311 conversion_settings
.ignore_beaming
= True
312 progress (_ ("Encountered file created by Dolet 3.4 for Sibelius, containing wrong beaming information. All beaming information in the MusicXML file will be ignored"))
313 # ditto for Dolet 3.5
314 if "Dolet 3.5 for Sibelius" in software
:
315 conversion_settings
.ignore_beaming
= True
316 progress (_ ("Encountered file created by Dolet 3.5 for Sibelius, containing wrong beaming information. All beaming information in the MusicXML file will be ignored"))
317 if "Noteworthy Composer" in software
:
318 conversion_settings
.ignore_beaming
= True
319 progress (_ ("Encountered file created by Noteworthy Composer's nwc2xml, containing wrong beaming information. All beaming information in the MusicXML file will be ignored"))
320 # TODO: Check for other unsupported features
329 return len (self
.start
) + len (self
.end
) == 0
330 def add_start (self
, g
):
331 self
.start
[getattr (g
, 'number', "1")] = g
332 def add_end (self
, g
):
333 self
.end
[getattr (g
, 'number', "1")] = g
334 def print_ly (self
, printer
):
335 error_message (_ ("Unprocessed PartGroupInfo %s encountered") % self
)
336 def ly_expression (self
):
337 error_message (_ ("Unprocessed PartGroupInfo %s encountered") % self
)
340 def staff_attributes_to_string_tunings (mxl_attr
):
341 details
= mxl_attr
.get_maybe_exist_named_child ('staff-details')
345 staff_lines
= details
.get_maybe_exist_named_child ('staff-lines')
347 lines
= string
.atoi (staff_lines
.get_text ())
350 staff_tunings
= details
.get_named_children ('staff-tuning')
351 for i
in staff_tunings
:
355 line
= string
.atoi (i
.line
) - 1
360 step
= i
.get_named_child (u
'tuning-step')
361 step
= step
.get_text ().strip ()
362 p
.step
= musicxml_step_to_lily (step
)
364 octave
= i
.get_named_child (u
'tuning-octave')
365 octave
= octave
.get_text ().strip ()
366 p
.octave
= int (octave
) - 4
368 alter
= i
.get_named_child (u
'tuning-alter')
370 p
.alteration
= int (alter
.get_text ().strip ())
371 # lilypond seems to use the opposite ordering than MusicXML...
377 def staff_attributes_to_lily_staff (mxl_attr
):
379 return musicexp
.Staff ()
381 (staff_id
, attributes
) = mxl_attr
.items ()[0]
383 # distinguish by clef:
384 # percussion (percussion and rhythmic), tab, and everything else
386 clef
= attributes
.get_maybe_exist_named_child ('clef')
388 sign
= clef
.get_maybe_exist_named_child ('sign')
390 clef_sign
= {"percussion": "percussion", "TAB": "tab"}.get (sign
.get_text (), None)
393 details
= attributes
.get_named_children ('staff-details')
395 staff_lines
= d
.get_maybe_exist_named_child ('staff-lines')
397 lines
= string
.atoi (staff_lines
.get_text ())
400 if clef_sign
== "percussion" and lines
== 1:
401 staff
= musicexp
.RhythmicStaff ()
402 elif clef_sign
== "percussion":
403 staff
= musicexp
.DrumStaff ()
404 # staff.drum_style_table = ???
405 elif clef_sign
== "tab":
406 staff
= musicexp
.TabStaff ()
407 staff
.string_tunings
= staff_attributes_to_string_tunings (attributes
)
408 # staff.tablature_format = ???
410 # TODO: Handle case with lines <> 5!
411 staff
= musicexp
.Staff ()
416 def extract_score_structure (part_list
, staffinfo
):
417 score
= musicexp
.Score ()
418 structure
= musicexp
.StaffGroup (None)
419 score
.set_contents (structure
)
424 def read_score_part (el
):
425 if not isinstance (el
, musicxml
.Score_part
):
427 # Depending on the attributes of the first measure, we create different
428 # types of staves (Staff, RhythmicStaff, DrumStaff, TabStaff, etc.)
429 staff
= staff_attributes_to_lily_staff (staffinfo
.get (el
.id, None))
433 partname
= el
.get_maybe_exist_named_child ('part-name')
434 # Finale gives unnamed parts the name "MusicXML Part" automatically!
435 if partname
and partname
.get_text() != "MusicXML Part":
436 staff
.instrument_name
= partname
.get_text ()
437 if el
.get_maybe_exist_named_child ('part-abbreviation'):
438 staff
.short_instrument_name
= el
.get_maybe_exist_named_child ('part-abbreviation').get_text ()
439 # TODO: Read in the MIDI device / instrument
442 def read_score_group (el
):
443 if not isinstance (el
, musicxml
.Part_group
):
445 group
= musicexp
.StaffGroup ()
446 if hasattr (el
, 'number'):
449 #currentgroups_dict[id] = group
450 #currentgroups.append (id)
451 if el
.get_maybe_exist_named_child ('group-name'):
452 group
.instrument_name
= el
.get_maybe_exist_named_child ('group-name').get_text ()
453 if el
.get_maybe_exist_named_child ('group-abbreviation'):
454 group
.short_instrument_name
= el
.get_maybe_exist_named_child ('group-abbreviation').get_text ()
455 if el
.get_maybe_exist_named_child ('group-symbol'):
456 group
.symbol
= el
.get_maybe_exist_named_child ('group-symbol').get_text ()
457 if el
.get_maybe_exist_named_child ('group-barline'):
458 group
.spanbar
= el
.get_maybe_exist_named_child ('group-barline').get_text ()
462 parts_groups
= part_list
.get_all_children ()
464 # the start/end group tags are not necessarily ordered correctly and groups
465 # might even overlap, so we can't go through the children sequentially!
467 # 1) Replace all Score_part objects by their corresponding Staff objects,
468 # also collect all group start/stop points into one PartGroupInfo object
470 group_info
= PartGroupInfo ()
471 for el
in parts_groups
:
472 if isinstance (el
, musicxml
.Score_part
):
473 if not group_info
.is_empty ():
474 staves
.append (group_info
)
475 group_info
= PartGroupInfo ()
476 staff
= read_score_part (el
)
478 staves
.append (staff
)
479 elif isinstance (el
, musicxml
.Part_group
):
480 if el
.type == "start":
481 group_info
.add_start (el
)
482 elif el
.type == "stop":
483 group_info
.add_end (el
)
484 if not group_info
.is_empty ():
485 staves
.append (group_info
)
487 # 2) Now, detect the groups:
490 while pos
< len (staves
):
492 if isinstance (el
, PartGroupInfo
):
494 if len (group_starts
) > 0:
495 prev_start
= group_starts
[-1]
496 elif len (el
.end
) > 0: # no group to end here
498 if len (el
.end
) > 0: # closes an existing group
499 ends
= el
.end
.keys ()
500 prev_started
= staves
[prev_start
].start
.keys ()
502 intersection
= filter(lambda x
:x
in ends
, prev_started
)
503 if len (intersection
) > 0:
504 grpid
= intersection
[0]
506 # Close the last started group
507 grpid
= staves
[prev_start
].start
.keys () [0]
508 # Find the corresponding closing tag and remove it!
511 while j
< len (staves
) and not foundclosing
:
512 if isinstance (staves
[j
], PartGroupInfo
) and staves
[j
].end
.has_key (grpid
):
514 del staves
[j
].end
[grpid
]
515 if staves
[j
].is_empty ():
518 grpobj
= staves
[prev_start
].start
[grpid
]
519 group
= read_score_group (grpobj
)
520 # remove the id from both the start and end
521 if el
.end
.has_key (grpid
):
523 del staves
[prev_start
].start
[grpid
]
526 # replace the staves with the whole group
527 for j
in staves
[(prev_start
+ 1):pos
]:
528 group
.append_staff (j
)
529 del staves
[(prev_start
+ 1):pos
]
530 staves
.insert (prev_start
+ 1, group
)
531 # reset pos so that we continue at the correct position
533 # remove an empty start group
534 if staves
[prev_start
].is_empty ():
535 del staves
[prev_start
]
536 group_starts
.remove (prev_start
)
538 elif len (el
.start
) > 0: # starts new part groups
539 group_starts
.append (pos
)
542 if len (staves
) == 1:
545 structure
.append_staff (i
)
549 def musicxml_duration_to_lily (mxl_note
):
550 # if the note has no Type child, then that method returns None. In that case,
551 # use the <duration> tag instead. If that doesn't exist, either -> Error
552 dur
= mxl_note
.get_duration_info ()
554 d
= musicexp
.Duration ()
555 d
.duration_log
= dur
[0]
557 # Grace notes by specification have duration 0, so no time modification
558 # factor is possible. It even messes up the output with *0/1
559 if not mxl_note
.get_maybe_exist_typed_child (musicxml
.Grace
):
560 d
.factor
= mxl_note
._duration
/ d
.get_length ()
564 if mxl_note
._duration
> 0:
565 return rational_to_lily_duration (mxl_note
._duration
)
567 mxl_note
.message (_ ("Encountered note at %s without type and duration (=%s)") % (mxl_note
.start
, mxl_note
._duration
) )
571 def rational_to_lily_duration (rational_len
):
572 d
= musicexp
.Duration ()
574 rational_len
.normalize_self ()
575 d_log
= {1: 0, 2: 1, 4:2, 8:3, 16:4, 32:5, 64:6, 128:7, 256:8, 512:9}.get (rational_len
.denominator (), -1)
577 # Duration of the form 1/2^n or 3/2^n can be converted to a simple lilypond duration
578 if (d_log
>= 0 and rational_len
.numerator() in (1,3,5,7) ):
579 # account for the dots!
580 d
.dots
= (rational_len
.numerator()-1)/2
581 d
.duration_log
= d_log
- d
.dots
583 d
.duration_log
= d_log
584 d
.factor
= Rational (rational_len
.numerator ())
586 error_message (_ ("Encountered rational duration with denominator %s, "
587 "unable to convert to lilypond duration") %
588 rational_len
.denominator ())
589 # TODO: Test the above error message
594 def musicxml_partial_to_lily (partial_len
):
596 p
= musicexp
.Partial ()
597 p
.partial
= rational_to_lily_duration (partial_len
)
602 # Detect repeats and alternative endings in the chord event list (music_list)
603 # and convert them to the corresponding musicexp objects, containing nested
605 def group_repeats (music_list
):
606 repeat_replaced
= True
609 # Walk through the list of expressions, looking for repeat structure
610 # (repeat start/end, corresponding endings). If we find one, try to find the
611 # last event of the repeat, replace the whole structure and start over again.
612 # For nested repeats, as soon as we encounter another starting repeat bar,
613 # treat that one first, and start over for the outer repeat.
614 while repeat_replaced
and i
< 100:
616 repeat_start
= -1 # position of repeat start / end
617 repeat_end
= -1 # position of repeat start / end
619 ending_start
= -1 # position of current ending start
620 endings
= [] # list of already finished endings
622 last
= len (music_list
) - 1
623 repeat_replaced
= False
625 while pos
< len (music_list
) and not repeat_replaced
:
627 repeat_finished
= False
628 if isinstance (e
, RepeatMarker
):
629 if not repeat_times
and e
.times
:
630 repeat_times
= e
.times
631 if e
.direction
== -1:
633 repeat_finished
= True
639 elif e
.direction
== 1:
645 elif isinstance (e
, EndingMarker
):
646 if e
.direction
== -1:
652 elif e
.direction
== 1:
655 endings
.append ([ending_start
, pos
])
658 elif not isinstance (e
, musicexp
.BarLine
):
659 # As soon as we encounter an element when repeat start and end
660 # is set and we are not inside an alternative ending,
661 # this whole repeat structure is finished => replace it
662 if repeat_start
>= 0 and repeat_end
> 0 and ending_start
< 0:
663 repeat_finished
= True
665 # Finish off all repeats without explicit ending bar (e.g. when
666 # we convert only one page of a multi-page score with repeats)
667 if pos
== last
and repeat_start
>= 0:
668 repeat_finished
= True
672 if ending_start
>= 0:
673 endings
.append ([ending_start
, pos
])
677 # We found the whole structure replace it!
678 r
= musicexp
.RepeatedMusic ()
679 if repeat_times
<= 0:
681 r
.repeat_count
= repeat_times
682 # don't erase the first element for "implicit" repeats (i.e. no
683 # starting repeat bars at the very beginning)
684 start
= repeat_start
+1
685 if repeat_start
== music_start
:
687 r
.set_music (music_list
[start
:repeat_end
])
688 for (start
, end
) in endings
:
689 s
= musicexp
.SequentialMusic ()
690 s
.elements
= music_list
[start
+1:end
]
692 del music_list
[repeat_start
:final_marker
+1]
693 music_list
.insert (repeat_start
, r
)
694 repeat_replaced
= True
696 # TODO: Implement repeats until the end without explicit ending bar
700 # Extract the settings for tuplets from the <notations><tuplet> and the
701 # <time-modification> elements of the note:
702 def musicxml_tuplet_to_lily (tuplet_elt
, time_modification
):
703 tsm
= musicexp
.TimeScaledMusic ()
705 if time_modification
:
706 fraction
= time_modification
.get_fraction ()
707 tsm
.numerator
= fraction
[0]
708 tsm
.denominator
= fraction
[1]
711 normal_type
= tuplet_elt
.get_normal_type ()
712 if not normal_type
and time_modification
:
713 normal_type
= time_modification
.get_normal_type ()
714 if not normal_type
and time_modification
:
715 note
= time_modification
.get_parent ()
717 normal_type
= note
.get_duration_info ()
719 normal_note
= musicexp
.Duration ()
720 (normal_note
.duration_log
, normal_note
.dots
) = normal_type
721 tsm
.normal_type
= normal_note
723 actual_type
= tuplet_elt
.get_actual_type ()
725 actual_note
= musicexp
.Duration ()
726 (actual_note
.duration_log
, actual_note
.dots
) = actual_type
727 tsm
.actual_type
= actual_note
729 # Obtain non-default nrs of notes from the tuplet object!
730 tsm
.display_numerator
= tuplet_elt
.get_normal_nr ()
731 tsm
.display_denominator
= tuplet_elt
.get_actual_nr ()
734 if hasattr (tuplet_elt
, 'bracket') and tuplet_elt
.bracket
== "no":
735 tsm
.display_bracket
= None
736 elif hasattr (tuplet_elt
, 'line-shape') and getattr (tuplet_elt
, 'line-shape') == "curved":
737 tsm
.display_bracket
= "curved"
739 tsm
.display_bracket
= "bracket"
741 display_values
= {"none": None, "actual": "actual", "both": "both"}
742 if hasattr (tuplet_elt
, "show-number"):
743 tsm
.display_number
= display_values
.get (getattr (tuplet_elt
, "show-number"), "actual")
745 if hasattr (tuplet_elt
, "show-type"):
746 tsm
.display_type
= display_values
.get (getattr (tuplet_elt
, "show-type"), None)
751 def group_tuplets (music_list
, events
):
754 """Collect Musics from
755 MUSIC_LIST demarcated by EVENTS_LIST in TimeScaledMusic objects.
763 for (ev_chord
, tuplet_elt
, time_modification
) in events
:
764 while (j
< len (music_list
)):
765 if music_list
[j
] == ev_chord
:
769 if hasattr (tuplet_elt
, 'number'):
770 nr
= getattr (tuplet_elt
, 'number')
771 if tuplet_elt
.type == 'start':
772 tuplet_object
= musicxml_tuplet_to_lily (tuplet_elt
, time_modification
)
773 tuplet_info
= [j
, None, tuplet_object
]
774 indices
.append (tuplet_info
)
775 brackets
[nr
] = tuplet_info
776 elif tuplet_elt
.type == 'stop':
777 bracket_info
= brackets
.get (nr
, None)
779 bracket_info
[1] = j
# Set the ending position to j
784 for (i1
, i2
, tsm
) in indices
:
788 new_list
.extend (music_list
[last
:i1
])
789 seq
= musicexp
.SequentialMusic ()
791 seq
.elements
= music_list
[i1
:last
]
795 new_list
.append (tsm
)
796 #TODO: Handle nested tuplets!!!!
798 new_list
.extend (music_list
[last
:])
802 def musicxml_clef_to_lily (attributes
):
803 change
= musicexp
.ClefChange ()
804 (change
.type, change
.position
, change
.octave
) = attributes
.get_clef_information ()
807 def musicxml_time_to_lily (attributes
):
808 sig
= attributes
.get_time_signature ()
811 change
= musicexp
.TimeSignatureChange()
812 change
.fractions
= sig
813 if (len(sig
) != 2) or isinstance (sig
[0], list):
814 needed_additional_definitions
.append ("compound-time-signature")
816 time_elm
= attributes
.get_maybe_exist_named_child ('time')
817 if time_elm
and hasattr (time_elm
, 'symbol'):
818 change
.style
= { 'single-number': "'single-digit",
821 'normal': "'()"}.get (time_elm
.symbol
, "'()")
825 # TODO: Handle senza-misura measures
826 # TODO: Handle hidden time signatures (print-object="no")
827 # TODO: What shall we do if the symbol clashes with the sig? e.g. "cut"
828 # with 3/8 or "single-number" with (2+3)/8 or 3/8+2/4?
832 def musicxml_key_to_lily (attributes
):
833 key_sig
= attributes
.get_key_signature ()
834 if not key_sig
or not (isinstance (key_sig
, list) or isinstance (key_sig
, tuple)):
835 error_message (_ ("Unable to extract key signature!"))
838 change
= musicexp
.KeySignatureChange()
840 if len (key_sig
) == 2 and not isinstance (key_sig
[0], list):
841 # standard key signature, (fifths, mode)
842 (fifths
, mode
) = key_sig
845 start_pitch
= musicexp
.Pitch ()
846 start_pitch
.octave
= 0
860 start_pitch
.alteration
= a
862 error_message (_ ("unknown mode %s, expecting 'major' or 'minor' "
863 "or a church mode!") % mode
)
865 fifth
= musicexp
.Pitch()
871 for x
in range (fifths
):
872 start_pitch
= start_pitch
.transposed (fifth
)
873 change
.tonic
= start_pitch
876 # Non-standard key signature of the form [[step,alter<,octave>],...]
877 change
.non_standard_alterations
= key_sig
880 def musicxml_transpose_to_lily (attributes
):
881 transpose
= attributes
.get_transposition ()
885 shift
= musicexp
.Pitch ()
886 octave_change
= transpose
.get_maybe_exist_named_child ('octave-change')
888 shift
.octave
= string
.atoi (octave_change
.get_text ())
889 chromatic_shift
= string
.atoi (transpose
.get_named_child ('chromatic').get_text ())
890 chromatic_shift_normalized
= chromatic_shift
% 12;
891 (shift
.step
, shift
.alteration
) = [
892 (0,0), (0,1), (1,0), (2,-1), (2,0),
893 (3,0), (3,1), (4,0), (5,-1), (5,0),
894 (6,-1), (6,0)][chromatic_shift_normalized
];
896 shift
.octave
+= (chromatic_shift
- chromatic_shift_normalized
) / 12
898 diatonic
= transpose
.get_maybe_exist_named_child ('diatonic')
900 diatonic_step
= string
.atoi (diatonic
.get_text ()) % 7
901 if diatonic_step
!= shift
.step
:
902 # We got the alter incorrect!
903 old_semitones
= shift
.semitones ()
904 shift
.step
= diatonic_step
905 new_semitones
= shift
.semitones ()
906 shift
.alteration
+= old_semitones
- new_semitones
908 transposition
= musicexp
.Transposition ()
909 transposition
.pitch
= musicexp
.Pitch ().transposed (shift
)
913 def musicxml_attributes_to_lily (attrs
):
916 'clef': musicxml_clef_to_lily
,
917 'time': musicxml_time_to_lily
,
918 'key': musicxml_key_to_lily
,
919 'transpose': musicxml_transpose_to_lily
,
921 for (k
, func
) in attr_dispatch
.items ():
922 children
= attrs
.get_named_children (k
)
930 class Marker (musicexp
.Music
):
934 def print_ly (self
, printer
):
935 ly
.stderr_write (_ ("Encountered unprocessed marker %s\n") % self
)
937 def ly_expression (self
):
939 class RepeatMarker (Marker
):
941 Marker
.__init
__ (self
)
943 class EndingMarker (Marker
):
946 # Convert the <barline> element to musicxml.BarLine (for non-standard barlines)
947 # and to RepeatMarker and EndingMarker objects for repeat and
948 # alternatives start/stops
949 def musicxml_barline_to_lily (barline
):
950 # retval contains all possible markers in the order:
951 # 0..bw_ending, 1..bw_repeat, 2..barline, 3..fw_repeat, 4..fw_ending
953 bartype_element
= barline
.get_maybe_exist_named_child ("bar-style")
954 repeat_element
= barline
.get_maybe_exist_named_child ("repeat")
955 ending_element
= barline
.get_maybe_exist_named_child ("ending")
959 bartype
= bartype_element
.get_text ()
961 if repeat_element
and hasattr (repeat_element
, 'direction'):
962 repeat
= RepeatMarker ()
963 repeat
.direction
= {"forward": -1, "backward": 1}.get (repeat_element
.direction
, 0)
965 if ( (repeat_element
.direction
== "forward" and bartype
== "heavy-light") or
966 (repeat_element
.direction
== "backward" and bartype
== "light-heavy") ):
968 if hasattr (repeat_element
, 'times'):
970 repeat
.times
= int (repeat_element
.times
)
973 repeat
.event
= barline
974 if repeat
.direction
== -1:
979 if ending_element
and hasattr (ending_element
, 'type'):
980 ending
= EndingMarker ()
981 ending
.direction
= {"start": -1, "stop": 1, "discontinue": 1}.get (ending_element
.type, 0)
982 ending
.event
= barline
983 if ending
.direction
== -1:
989 b
= musicexp
.BarLine ()
993 return retval
.values ()
995 spanner_event_dict
= {
996 'beam' : musicexp
.BeamEvent
,
997 'dashes' : musicexp
.TextSpannerEvent
,
998 'bracket' : musicexp
.BracketSpannerEvent
,
999 'glissando' : musicexp
.GlissandoEvent
,
1000 'octave-shift' : musicexp
.OctaveShiftEvent
,
1001 'pedal' : musicexp
.PedalEvent
,
1002 'slide' : musicexp
.GlissandoEvent
,
1003 'slur' : musicexp
.SlurEvent
,
1004 'wavy-line' : musicexp
.TrillSpanEvent
,
1005 'wedge' : musicexp
.HairpinEvent
1007 spanner_type_dict
= {
1021 def musicxml_spanner_to_lily_event (mxl_event
):
1024 name
= mxl_event
.get_name()
1025 func
= spanner_event_dict
.get (name
)
1029 error_message (_ ('unknown span event %s') % mxl_event
)
1032 type = mxl_event
.get_type ()
1033 span_direction
= spanner_type_dict
.get (type)
1034 # really check for None, because some types will be translated to 0, which
1035 # would otherwise also lead to the unknown span warning
1036 if span_direction
!= None:
1037 ev
.span_direction
= span_direction
1039 error_message (_ ('unknown span type %s for %s') % (type, name
))
1041 ev
.set_span_type (type)
1042 ev
.line_type
= getattr (mxl_event
, 'line-type', 'solid')
1044 # assign the size, which is used for octave-shift, etc.
1045 ev
.size
= mxl_event
.get_size ()
1049 def musicxml_direction_to_indicator (direction
):
1050 return { "above": 1, "upright": 1, "up": 1, "below": -1, "downright": -1, "down": -1, "inverted": -1 }.get (direction
, 0)
1052 def musicxml_fermata_to_lily_event (mxl_event
):
1053 ev
= musicexp
.ArticulationEvent ()
1054 txt
= mxl_event
.get_text ()
1055 # The contents of the element defined the shape, possible are normal, angled and square
1056 ev
.type = { "angled": "shortfermata", "square": "longfermata" }.get (txt
, "fermata")
1057 if hasattr (mxl_event
, 'type'):
1058 dir = musicxml_direction_to_indicator (mxl_event
.type)
1059 if dir and options
.convert_directions
:
1060 ev
.force_direction
= dir
1063 def musicxml_arpeggiate_to_lily_event (mxl_event
):
1064 ev
= musicexp
.ArpeggioEvent ()
1065 ev
.direction
= musicxml_direction_to_indicator (getattr (mxl_event
, 'direction', None))
1068 def musicxml_nonarpeggiate_to_lily_event (mxl_event
):
1069 ev
= musicexp
.ArpeggioEvent ()
1070 ev
.non_arpeggiate
= True
1071 ev
.direction
= musicxml_direction_to_indicator (getattr (mxl_event
, 'direction', None))
1074 def musicxml_tremolo_to_lily_event (mxl_event
):
1075 ev
= musicexp
.TremoloEvent ()
1076 txt
= mxl_event
.get_text ()
1083 def musicxml_falloff_to_lily_event (mxl_event
):
1084 ev
= musicexp
.BendEvent ()
1088 def musicxml_doit_to_lily_event (mxl_event
):
1089 ev
= musicexp
.BendEvent ()
1093 def musicxml_bend_to_lily_event (mxl_event
):
1094 ev
= musicexp
.BendEvent ()
1095 ev
.alter
= mxl_event
.bend_alter ()
1098 def musicxml_caesura_to_lily_event (mxl_event
):
1099 ev
= musicexp
.MarkupEvent ()
1100 # FIXME: default to straight or curved caesura?
1101 ev
.contents
= "\\musicglyph #\"scripts.caesura.straight\""
1102 ev
.force_direction
= 1
1105 def musicxml_fingering_event (mxl_event
):
1106 ev
= musicexp
.ShortArticulationEvent ()
1107 ev
.type = mxl_event
.get_text ()
1110 def musicxml_string_event (mxl_event
):
1111 ev
= musicexp
.NoDirectionArticulationEvent ()
1112 ev
.type = mxl_event
.get_text ()
1115 def musicxml_accidental_mark (mxl_event
):
1116 ev
= musicexp
.MarkupEvent ()
1117 contents
= { "sharp": "\\sharp",
1118 "natural": "\\natural",
1120 "double-sharp": "\\doublesharp",
1121 "sharp-sharp": "\\sharp\\sharp",
1122 "flat-flat": "\\flat\\flat",
1123 "flat-flat": "\\doubleflat",
1124 "natural-sharp": "\\natural\\sharp",
1125 "natural-flat": "\\natural\\flat",
1126 "quarter-flat": "\\semiflat",
1127 "quarter-sharp": "\\semisharp",
1128 "three-quarters-flat": "\\sesquiflat",
1129 "three-quarters-sharp": "\\sesquisharp",
1130 }.get (mxl_event
.get_text ())
1132 ev
.contents
= contents
1137 # translate articulations, ornaments and other notations into ArticulationEvents
1139 # -) string (ArticulationEvent with that name)
1140 # -) function (function(mxl_event) needs to return a full ArticulationEvent-derived object
1141 # -) (class, name) (like string, only that a different class than ArticulationEvent is used)
1142 # TODO: Some translations are missing!
1143 articulations_dict
= {
1144 "accent": (musicexp
.ShortArticulationEvent
, ">"), # or "accent"
1145 "accidental-mark": musicxml_accidental_mark
,
1146 "bend": musicxml_bend_to_lily_event
,
1147 "breath-mark": (musicexp
.NoDirectionArticulationEvent
, "breathe"),
1148 "caesura": musicxml_caesura_to_lily_event
,
1149 #"delayed-turn": "?",
1150 "detached-legato": (musicexp
.ShortArticulationEvent
, "_"), # or "portato"
1151 "doit": musicxml_doit_to_lily_event
,
1152 #"double-tongue": "?",
1153 "down-bow": "downbow",
1154 "falloff": musicxml_falloff_to_lily_event
,
1155 "fingering": musicxml_fingering_event
,
1156 #"fingernails": "?",
1159 "harmonic": "flageolet",
1161 "inverted-mordent": "prall",
1162 "inverted-turn": "reverseturn",
1163 "mordent": "mordent",
1164 "open-string": "open",
1171 "snap-pizzicato": "snappizzicato",
1173 "staccatissimo": (musicexp
.ShortArticulationEvent
, "|"), # or "staccatissimo"
1174 "staccato": (musicexp
.ShortArticulationEvent
, "."), # or "staccato"
1175 "stopped": (musicexp
.ShortArticulationEvent
, "+"), # or "stopped"
1177 "string": musicxml_string_event
,
1178 "strong-accent": (musicexp
.ShortArticulationEvent
, "^"), # or "marcato"
1180 "tenuto": (musicexp
.ShortArticulationEvent
, "-"), # or "tenuto"
1181 "thumb-position": "thumb",
1184 "tremolo": musicxml_tremolo_to_lily_event
,
1185 "trill-mark": "trill",
1186 #"triple-tongue": "?",
1191 articulation_spanners
= [ "wavy-line" ]
1193 def musicxml_articulation_to_lily_event (mxl_event
):
1194 # wavy-line elements are treated as trill spanners, not as articulation ornaments
1195 if mxl_event
.get_name () in articulation_spanners
:
1196 return musicxml_spanner_to_lily_event (mxl_event
)
1198 tmp_tp
= articulations_dict
.get (mxl_event
.get_name ())
1202 if isinstance (tmp_tp
, str):
1203 ev
= musicexp
.ArticulationEvent ()
1205 elif isinstance (tmp_tp
, tuple):
1209 ev
= tmp_tp (mxl_event
)
1211 # Some articulations use the type attribute, other the placement...
1213 if hasattr (mxl_event
, 'type') and options
.convert_directions
:
1214 dir = musicxml_direction_to_indicator (mxl_event
.type)
1215 if hasattr (mxl_event
, 'placement') and options
.convert_directions
:
1216 dir = musicxml_direction_to_indicator (mxl_event
.placement
)
1218 ev
.force_direction
= dir
1223 def musicxml_dynamics_to_lily_event (dynentry
):
1224 dynamics_available
= (
1225 "ppppp", "pppp", "ppp", "pp", "p", "mp", "mf",
1226 "f", "ff", "fff", "ffff", "fp", "sf", "sff", "sp", "spp", "sfz", "rfz" )
1227 dynamicsname
= dynentry
.get_name ()
1228 if dynamicsname
== "other-dynamics":
1229 dynamicsname
= dynentry
.get_text ()
1230 if not dynamicsname
or dynamicsname
=="#text":
1233 if not dynamicsname
in dynamics_available
:
1234 # Get rid of - in tag names (illegal in ly tags!)
1235 dynamicstext
= dynamicsname
1236 dynamicsname
= string
.replace (dynamicsname
, "-", "")
1237 additional_definitions
[dynamicsname
] = dynamicsname
+ \
1238 " = #(make-dynamic-script \"" + dynamicstext
+ "\")"
1239 needed_additional_definitions
.append (dynamicsname
)
1240 event
= musicexp
.DynamicsEvent ()
1241 event
.type = dynamicsname
1244 # Convert single-color two-byte strings to numbers 0.0 - 1.0
1245 def hexcolorval_to_nr (hex_val
):
1247 v
= int (hex_val
, 16)
1254 def hex_to_color (hex_val
):
1255 res
= re
.match (r
'#([0-9a-f][0-9a-f]|)([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])$', hex_val
, re
.IGNORECASE
)
1257 return map (lambda x
: hexcolorval_to_nr (x
), res
.group (2,3,4))
1261 def musicxml_words_to_lily_event (words
):
1262 event
= musicexp
.TextEvent ()
1263 text
= words
.get_text ()
1264 text
= re
.sub ('^ *\n? *', '', text
)
1265 text
= re
.sub (' *\n? *$', '', text
)
1268 if hasattr (words
, 'default-y') and options
.convert_directions
:
1269 offset
= getattr (words
, 'default-y')
1271 off
= string
.atoi (offset
)
1273 event
.force_direction
= 1
1275 event
.force_direction
= -1
1277 event
.force_direction
= 0
1279 if hasattr (words
, 'font-weight'):
1280 font_weight
= { "normal": '', "bold": '\\bold' }.get (getattr (words
, 'font-weight'), '')
1282 event
.markup
+= font_weight
1284 if hasattr (words
, 'font-size'):
1285 size
= getattr (words
, 'font-size')
1287 "xx-small": '\\teeny',
1288 "x-small": '\\tiny',
1292 "x-large": '\\huge',
1293 "xx-large": '\\larger\\huge'
1296 event
.markup
+= font_size
1298 if hasattr (words
, 'color'):
1299 color
= getattr (words
, 'color')
1300 rgb
= hex_to_color (color
)
1302 event
.markup
+= "\\with-color #(rgb-color %s %s %s)" % (rgb
[0], rgb
[1], rgb
[2])
1304 if hasattr (words
, 'font-style'):
1305 font_style
= { "italic": '\\italic' }.get (getattr (words
, 'font-style'), '')
1307 event
.markup
+= font_style
1309 # TODO: How should I best convert the font-family attribute?
1311 # TODO: How can I represent the underline, overline and line-through
1312 # attributes in Lilypond? Values of these attributes indicate
1313 # the number of lines
1318 # convert accordion-registration to lilypond.
1319 # Since lilypond does not have any built-in commands, we need to create
1320 # the markup commands manually and define our own variables.
1321 # Idea was taken from: http://lsr.dsi.unimi.it/LSR/Item?id=194
1322 def musicxml_accordion_to_markup (mxl_event
):
1323 commandname
= "accReg"
1326 high
= mxl_event
.get_maybe_exist_named_child ('accordion-high')
1329 command
+= """\\combine
1330 \\raise #2.5 \\musicglyph #\"accordion.accDot\"
1332 middle
= mxl_event
.get_maybe_exist_named_child ('accordion-middle')
1334 # By default, use one dot (when no or invalid content is given). The
1335 # MusicXML spec is quiet about this case...
1338 txt
= string
.atoi (middle
.get_text ())
1342 commandname
+= "MMM"
1343 command
+= """\\combine
1344 \\raise #1.5 \\musicglyph #\"accordion.accDot\"
1346 \\raise #1.5 \\translate #(cons 1 0) \\musicglyph #\"accordion.accDot\"
1348 \\raise #1.5 \\translate #(cons -1 0) \\musicglyph #\"accordion.accDot\"
1352 command
+= """\\combine
1353 \\raise #1.5 \\translate #(cons 0.5 0) \\musicglyph #\"accordion.accDot\"
1355 \\raise #1.5 \\translate #(cons -0.5 0) \\musicglyph #\"accordion.accDot\"
1359 command
+= """\\combine
1360 \\raise #1.5 \\musicglyph #\"accordion.accDot\"
1362 low
= mxl_event
.get_maybe_exist_named_child ('accordion-low')
1365 command
+= """\\combine
1366 \\raise #0.5 \musicglyph #\"accordion.accDot\"
1369 command
+= "\musicglyph #\"accordion.accDiscant\""
1370 command
= "\\markup { \\normalsize %s }" % command
1371 # Define the newly built command \accReg[H][MMM][L]
1372 additional_definitions
[commandname
] = "%s = %s" % (commandname
, command
)
1373 needed_additional_definitions
.append (commandname
)
1374 return "\\%s" % commandname
1376 def musicxml_accordion_to_ly (mxl_event
):
1377 txt
= musicxml_accordion_to_markup (mxl_event
)
1379 ev
= musicexp
.MarkEvent (txt
)
1384 def musicxml_rehearsal_to_ly_mark (mxl_event
):
1385 text
= mxl_event
.get_text ()
1388 # default is boxed rehearsal marks!
1390 if hasattr (mxl_event
, 'enclosure'):
1391 encl
= {"none": None, "square": "box", "circle": "circle" }.get (mxl_event
.enclosure
, None)
1393 text
= "\\%s { %s }" % (encl
, text
)
1394 ev
= musicexp
.MarkEvent ("\\markup { %s }" % text
)
1397 def musicxml_harp_pedals_to_ly (mxl_event
):
1399 result
= "\\harp-pedal #\""
1400 for t
in mxl_event
.get_named_children ('pedal-tuning'):
1401 alter
= t
.get_named_child ('pedal-alter')
1403 val
= int (alter
.get_text ().strip ())
1404 result
+= {1: "v", 0: "-", -1: "^"}.get (val
, "")
1408 ev
= musicexp
.MarkupEvent ()
1409 ev
.contents
= result
+ "\""
1412 def musicxml_eyeglasses_to_ly (mxl_event
):
1413 needed_additional_definitions
.append ("eyeglasses")
1414 return musicexp
.MarkEvent ("\\markup { \\eyeglasses }")
1416 def next_non_hash_index (lst
, pos
):
1418 while pos
< len (lst
) and isinstance (lst
[pos
], musicxml
.Hash_text
):
1422 def musicxml_metronome_to_ly (mxl_event
):
1423 children
= mxl_event
.get_all_children ()
1428 index
= next_non_hash_index (children
, index
)
1429 if isinstance (children
[index
], musicxml
.BeatUnit
):
1430 # first form of metronome-mark, using unit and beats/min or other unit
1431 ev
= musicexp
.TempoMark ()
1432 if hasattr (mxl_event
, 'parentheses'):
1433 ev
.set_parentheses (mxl_event
.parentheses
== "yes")
1435 d
= musicexp
.Duration ()
1436 d
.duration_log
= musicxml
.musicxml_duration_to_log (children
[index
].get_text ())
1437 index
= next_non_hash_index (children
, index
)
1438 if isinstance (children
[index
], musicxml
.BeatUnitDot
):
1440 index
= next_non_hash_index (children
, index
)
1441 ev
.set_base_duration (d
)
1442 if isinstance (children
[index
], musicxml
.BeatUnit
):
1443 # Form "note = newnote"
1444 newd
= musicexp
.Duration ()
1445 newd
.duration_log
= musicxml
.musicxml_duration_to_log (children
[index
].get_text ())
1446 index
= next_non_hash_index (children
, index
)
1447 if isinstance (children
[index
], musicxml
.BeatUnitDot
):
1449 index
= next_non_hash_index (children
, index
)
1450 ev
.set_new_duration (newd
)
1451 elif isinstance (children
[index
], musicxml
.PerMinute
):
1454 beats
= int (children
[index
].get_text ())
1455 ev
.set_beats_per_minute (beats
)
1459 error_message (_ ("Unknown metronome mark, ignoring"))
1463 #TODO: Implement the other (more complex) way for tempo marks!
1464 error_message (_ ("Metronome marks with complex relations (<metronome-note> in MusicXML) are not yet implemented."))
1467 # translate directions into Events, possible values:
1468 # -) string (MarkEvent with that command)
1469 # -) function (function(mxl_event) needs to return a full Event-derived object
1470 # -) (class, name) (like string, only that a different class than MarkEvent is used)
1472 'accordion-registration' : musicxml_accordion_to_ly
,
1473 'coda' : (musicexp
.MusicGlyphMarkEvent
, "coda"),
1476 'eyeglasses': musicxml_eyeglasses_to_ly
,
1477 'harp-pedals' : musicxml_harp_pedals_to_ly
,
1479 'metronome' : musicxml_metronome_to_ly
,
1480 'rehearsal' : musicxml_rehearsal_to_ly_mark
,
1481 # 'scordatura' : ???
1482 'segno' : (musicexp
.MusicGlyphMarkEvent
, "segno"),
1483 'words' : musicxml_words_to_lily_event
,
1485 directions_spanners
= [ 'octave-shift', 'pedal', 'wedge', 'dashes', 'bracket' ]
1487 def musicxml_direction_to_lily (n
):
1488 # TODO: Handle the <staff> element!
1490 # placement applies to all children!
1492 if hasattr (n
, 'placement') and options
.convert_directions
:
1493 dir = musicxml_direction_to_indicator (n
.placement
)
1494 dirtype_children
= []
1495 # TODO: The direction-type is used for grouping (e.g. dynamics with text),
1496 # so we can't simply flatten them out!
1497 for dt
in n
.get_typed_children (musicxml
.DirType
):
1498 dirtype_children
+= dt
.get_all_children ()
1500 for entry
in dirtype_children
:
1501 # backets, dashes, octave shifts. pedal marks, hairpins etc. are spanners:
1502 if entry
.get_name() in directions_spanners
:
1503 event
= musicxml_spanner_to_lily_event (entry
)
1508 # now treat all the "simple" ones, that can be translated using the dict
1510 tmp_tp
= directions_dict
.get (entry
.get_name (), None)
1511 if isinstance (tmp_tp
, str): # string means MarkEvent
1512 ev
= musicexp
.MarkEvent (tmp_tp
)
1513 elif isinstance (tmp_tp
, tuple): # tuple means (EventClass, "text")
1514 ev
= tmp_tp
[0] (tmp_tp
[1])
1518 # TODO: set the correct direction! Unfortunately, \mark in ly does
1519 # not seem to support directions!
1523 if entry
.get_name () == "dynamics":
1524 for dynentry
in entry
.get_all_children ():
1525 ev
= musicxml_dynamics_to_lily_event (dynentry
)
1531 def musicxml_frame_to_lily_event (frame
):
1532 ev
= musicexp
.FretEvent ()
1533 ev
.strings
= frame
.get_strings ()
1534 ev
.frets
= frame
.get_frets ()
1535 #offset = frame.get_first_fret () - 1
1537 for fn
in frame
.get_named_children ('frame-note'):
1538 fret
= fn
.get_fret ()
1541 el
= [ fn
.get_string (), fret
]
1542 fingering
= fn
.get_fingering ()
1544 el
.append (fingering
)
1545 ev
.elements
.append (el
)
1548 barre
[0] = el
[0] # start string
1549 barre
[2] = el
[1] # fret
1551 barre
[1] = el
[0] # end string
1556 def musicxml_harmony_to_lily (n
):
1558 for f
in n
.get_named_children ('frame'):
1559 ev
= musicxml_frame_to_lily_event (f
)
1565 notehead_styles_dict
= {
1567 'triangle': '\'triangle',
1568 'diamond': '\'diamond',
1569 'square': '\'la', # TODO: Proper squared note head
1570 'cross': None, # TODO: + shaped note head
1572 'circle-x': '\'xcircle',
1573 'inverted triangle': None, # TODO: Implement
1574 'arrow down': None, # TODO: Implement
1575 'arrow up': None, # TODO: Implement
1576 'slashed': None, # TODO: Implement
1577 'back slashed': None, # TODO: Implement
1579 'cluster': None, # TODO: Implement
1590 def musicxml_notehead_to_lily (nh
):
1594 style
= notehead_styles_dict
.get (nh
.get_text ().strip (), None)
1595 style_elm
= musicexp
.NotestyleEvent ()
1597 style_elm
.style
= style
1598 if hasattr (nh
, 'filled'):
1599 style_elm
.filled
= (getattr (nh
, 'filled') == "yes")
1600 if style_elm
.style
or (style_elm
.filled
!= None):
1601 styles
.append (style_elm
)
1604 if hasattr (nh
, 'parentheses') and (nh
.parentheses
== "yes"):
1605 styles
.append (musicexp
.ParenthesizeEvent ())
1609 def musicxml_chordpitch_to_lily (mxl_cpitch
):
1610 r
= musicexp
.ChordPitch ()
1611 r
.alteration
= mxl_cpitch
.get_alteration ()
1612 r
.step
= musicxml_step_to_lily (mxl_cpitch
.get_step ())
1618 'augmented': 'aug5',
1619 'diminished': 'dim5',
1622 'major-seventh': 'maj7',
1623 'minor-seventh': 'm7',
1624 'diminished-seventh': 'dim7',
1625 'augmented-seventh': 'aug7',
1626 'half-diminished': 'dim5m7',
1627 'major-minor': 'maj7m5',
1630 'minor-sixth': 'm6',
1632 'dominant-ninth': '9',
1633 'major-ninth': 'maj9',
1634 'minor-ninth': 'm9',
1635 # 11ths (usually as the basis for alteration):
1636 'dominant-11th': '11',
1637 'major-11th': 'maj11',
1638 'minor-11th': 'm11',
1639 # 13ths (usually as the basis for alteration):
1640 'dominant-13th': '13.11',
1641 'major-13th': 'maj13.11',
1642 'minor-13th': 'm13',
1644 'suspended-second': 'sus2',
1645 'suspended-fourth': 'sus4',
1646 # Functional sixths:
1648 #'Neapolitan': '???',
1653 #'pedal': '???',(pedal-point bass)
1660 def musicxml_chordkind_to_lily (kind
):
1661 res
= chordkind_dict
.get (kind
, None)
1662 # Check for None, since a major chord is converted to ''
1664 error_message (_ ("Unable to convert chord type %s to lilypond.") % kind
)
1667 def musicxml_harmony_to_lily_chordname (n
):
1669 root
= n
.get_maybe_exist_named_child ('root')
1671 ev
= musicexp
.ChordNameEvent ()
1672 ev
.root
= musicxml_chordpitch_to_lily (root
)
1673 kind
= n
.get_maybe_exist_named_child ('kind')
1675 ev
.kind
= musicxml_chordkind_to_lily (kind
.get_text ())
1678 bass
= n
.get_maybe_exist_named_child ('bass')
1680 ev
.bass
= musicxml_chordpitch_to_lily (bass
)
1681 inversion
= n
.get_maybe_exist_named_child ('inversion')
1683 # TODO: Lilypond does not support inversions, does it?
1685 # Mail from Carl Sorensen on lilypond-devel, June 11, 2008:
1686 # 4. LilyPond supports the first inversion in the form of added
1687 # bass notes. So the first inversion of C major would be c:/g.
1688 # To get the second inversion of C major, you would need to do
1689 # e:6-3-^5 or e:m6-^5. However, both of these techniques
1690 # require you to know the chord and calculate either the fifth
1691 # pitch (for the first inversion) or the third pitch (for the
1692 # second inversion) so they may not be helpful for musicxml2ly.
1693 inversion_count
= string
.atoi (inversion
.get_text ())
1694 if inversion_count
== 1:
1695 # TODO: Calculate the bass note for the inversion...
1698 for deg
in n
.get_named_children ('degree'):
1699 d
= musicexp
.ChordModification ()
1700 d
.type = deg
.get_type ()
1701 d
.step
= deg
.get_value ()
1702 d
.alteration
= deg
.get_alter ()
1703 ev
.add_modification (d
)
1704 #TODO: convert the user-symbols attribute:
1705 #major: a triangle, like Unicode 25B3
1706 #minor: -, like Unicode 002D
1707 #augmented: +, like Unicode 002B
1708 #diminished: (degree), like Unicode 00B0
1709 #half-diminished: (o with slash), like Unicode 00F8
1715 def musicxml_figured_bass_note_to_lily (n
):
1716 res
= musicexp
.FiguredBassNote ()
1717 suffix_dict
= { 'sharp' : "+",
1720 'double-sharp' : "++",
1722 'sharp-sharp' : "++",
1724 prefix
= n
.get_maybe_exist_named_child ('prefix')
1726 res
.set_prefix (suffix_dict
.get (prefix
.get_text (), ""))
1727 fnumber
= n
.get_maybe_exist_named_child ('figure-number')
1729 res
.set_number (fnumber
.get_text ())
1730 suffix
= n
.get_maybe_exist_named_child ('suffix')
1732 res
.set_suffix (suffix_dict
.get (suffix
.get_text (), ""))
1733 if n
.get_maybe_exist_named_child ('extend'):
1734 # TODO: Implement extender lines (unfortunately, in lilypond you have
1735 # to use \set useBassFigureExtenders = ##t, which turns them on
1736 # globally, while MusicXML has a property for each note...
1737 # I'm not sure there is a proper way to implement this cleanly
1744 def musicxml_figured_bass_to_lily (n
):
1745 if not isinstance (n
, musicxml
.FiguredBass
):
1747 res
= musicexp
.FiguredBassEvent ()
1748 for i
in n
.get_named_children ('figure'):
1749 note
= musicxml_figured_bass_note_to_lily (i
)
1752 dur
= n
.get_maybe_exist_named_child ('duration')
1754 # apply the duration to res
1755 length
= Rational(int(dur
.get_text()), n
._divisions
)*Rational(1,4)
1756 res
.set_real_duration (length
)
1757 duration
= rational_to_lily_duration (length
)
1759 res
.set_duration (duration
)
1760 if hasattr (n
, 'parentheses') and n
.parentheses
== "yes":
1761 res
.set_parentheses (True)
1764 instrument_drumtype_dict
= {
1765 'Acoustic Snare Drum': 'acousticsnare',
1766 'Side Stick': 'sidestick',
1767 'Open Triangle': 'opentriangle',
1768 'Mute Triangle': 'mutetriangle',
1769 'Tambourine': 'tambourine',
1770 'Bass Drum': 'bassdrum',
1773 def musicxml_note_to_lily_main_event (n
):
1778 mxl_pitch
= n
.get_maybe_exist_typed_child (musicxml
.Pitch
)
1780 pitch
= musicxml_pitch_to_lily (mxl_pitch
)
1781 event
= musicexp
.NoteEvent ()
1784 acc
= n
.get_maybe_exist_named_child ('accidental')
1786 # let's not force accs everywhere.
1787 event
.cautionary
= acc
.editorial
1789 elif n
.get_maybe_exist_typed_child (musicxml
.Unpitched
):
1790 # Unpitched elements have display-step and can also have
1792 unpitched
= n
.get_maybe_exist_typed_child (musicxml
.Unpitched
)
1793 event
= musicexp
.NoteEvent ()
1794 event
.pitch
= musicxml_unpitched_to_lily (unpitched
)
1796 elif n
.get_maybe_exist_typed_child (musicxml
.Rest
):
1797 # rests can have display-octave and display-step, which are
1798 # treated like an ordinary note pitch
1799 rest
= n
.get_maybe_exist_typed_child (musicxml
.Rest
)
1800 event
= musicexp
.RestEvent ()
1801 if options
.convert_rest_positions
:
1802 pitch
= musicxml_restdisplay_to_lily (rest
)
1805 elif n
.instrument_name
:
1806 event
= musicexp
.NoteEvent ()
1807 drum_type
= instrument_drumtype_dict
.get (n
.instrument_name
)
1809 event
.drum_type
= drum_type
1811 n
.message (_ ("drum %s type unknown, please add to instrument_drumtype_dict") % n
.instrument_name
)
1812 event
.drum_type
= 'acousticsnare'
1815 n
.message (_ ("cannot find suitable event"))
1818 event
.duration
= musicxml_duration_to_lily (n
)
1820 noteheads
= n
.get_named_children ('notehead')
1821 for nh
in noteheads
:
1822 styles
= musicxml_notehead_to_lily (nh
)
1824 event
.add_associated_event (s
)
1828 def musicxml_lyrics_to_text (lyrics
):
1829 # TODO: Implement text styles for lyrics syllables
1833 for e
in lyrics
.get_all_children ():
1834 if isinstance (e
, musicxml
.Syllabic
):
1835 continued
= e
.continued ()
1836 elif isinstance (e
, musicxml
.Text
):
1837 # We need to convert soft hyphens to -, otherwise the ascii codec as well
1838 # as lilypond will barf on that character
1839 text
+= string
.replace( e
.get_text(), u
'\xad', '-' )
1840 elif isinstance (e
, musicxml
.Elision
):
1845 elif isinstance (e
, musicxml
.Extend
):
1850 if text
== "-" and continued
:
1852 elif text
== "_" and extended
:
1854 elif continued
and text
:
1855 return musicxml
.escape_ly_output_string (text
) + " --"
1858 elif extended
and text
:
1859 return musicxml
.escape_ly_output_string (text
) + " __"
1863 return musicxml
.escape_ly_output_string (text
)
1869 def __init__ (self
, here
, dest
):
1873 class LilyPondVoiceBuilder
:
1874 def __init__ (self
):
1876 self
.pending_dynamics
= []
1877 self
.end_moment
= Rational (0)
1878 self
.begin_moment
= Rational (0)
1879 self
.pending_multibar
= Rational (0)
1880 self
.ignore_skips
= False
1881 self
.has_relevant_elements
= False
1882 self
.measure_length
= Rational (4, 4)
1884 def _insert_multibar (self
):
1885 layout_information
.set_context_item ('Score', 'skipBars = ##t')
1886 r
= musicexp
.MultiMeasureRest ()
1887 lenfrac
= self
.measure_length
1888 r
.duration
= rational_to_lily_duration (lenfrac
)
1889 r
.duration
.factor
*= self
.pending_multibar
/ lenfrac
1890 self
.elements
.append (r
)
1891 self
.begin_moment
= self
.end_moment
1892 self
.end_moment
= self
.begin_moment
+ self
.pending_multibar
1893 self
.pending_multibar
= Rational (0)
1895 def set_measure_length (self
, mlen
):
1896 if (mlen
!= self
.measure_length
) and self
.pending_multibar
:
1897 self
._insert
_multibar
()
1898 self
.measure_length
= mlen
1900 def add_multibar_rest (self
, duration
):
1901 self
.pending_multibar
+= duration
1903 def set_duration (self
, duration
):
1904 self
.end_moment
= self
.begin_moment
+ duration
1905 def current_duration (self
):
1906 return self
.end_moment
- self
.begin_moment
1908 def add_music (self
, music
, duration
):
1909 assert isinstance (music
, musicexp
.Music
)
1910 if self
.pending_multibar
> Rational (0):
1911 self
._insert
_multibar
()
1913 self
.has_relevant_elements
= True
1914 self
.elements
.append (music
)
1915 self
.begin_moment
= self
.end_moment
1916 self
.set_duration (duration
)
1918 # Insert all pending dynamics right after the note/rest:
1919 if isinstance (music
, musicexp
.ChordEvent
) and self
.pending_dynamics
:
1920 for d
in self
.pending_dynamics
:
1922 self
.pending_dynamics
= []
1924 # Insert some music command that does not affect the position in the measure
1925 def add_command (self
, command
):
1926 assert isinstance (command
, musicexp
.Music
)
1927 if self
.pending_multibar
> Rational (0):
1928 self
._insert
_multibar
()
1929 self
.has_relevant_elements
= True
1930 self
.elements
.append (command
)
1931 def add_barline (self
, barline
):
1932 # TODO: Implement merging of default barline and custom bar line
1933 self
.add_music (barline
, Rational (0))
1934 def add_partial (self
, command
):
1935 self
.ignore_skips
= True
1936 self
.add_command (command
)
1938 def add_dynamics (self
, dynamic
):
1939 # store the dynamic item(s) until we encounter the next note/rest:
1940 self
.pending_dynamics
.append (dynamic
)
1942 def add_bar_check (self
, number
):
1943 # re/store has_relevant_elements, so that a barline alone does not
1944 # trigger output for figured bass, chord names
1945 has_relevant
= self
.has_relevant_elements
1946 b
= musicexp
.BarLine ()
1947 b
.bar_number
= number
1948 self
.add_barline (b
)
1949 self
.has_relevant_elements
= has_relevant
1951 def jumpto (self
, moment
):
1952 current_end
= self
.end_moment
+ self
.pending_multibar
1953 diff
= moment
- current_end
1955 if diff
< Rational (0):
1956 error_message (_ ('Negative skip %s (from position %s to %s)') %
1957 (diff
, current_end
, moment
))
1960 if diff
> Rational (0) and not (self
.ignore_skips
and moment
== 0):
1961 skip
= musicexp
.SkipEvent()
1963 duration_log
= {1: 0, 2: 1, 4:2, 8:3, 16:4, 32:5, 64:6, 128:7, 256:8, 512:9}.get (diff
.denominator (), -1)
1965 # TODO: Use the time signature for skips, too. Problem: The skip
1966 # might not start at a measure boundary!
1967 if duration_log
> 0: # denominator is a power of 2...
1968 if diff
.numerator () == 3:
1972 duration_factor
= Rational (diff
.numerator ())
1974 # for skips of a whole or more, simply use s1*factor
1976 duration_factor
= diff
1977 skip
.duration
.duration_log
= duration_log
1978 skip
.duration
.factor
= duration_factor
1979 skip
.duration
.dots
= duration_dots
1981 evc
= musicexp
.ChordEvent ()
1982 evc
.elements
.append (skip
)
1983 self
.add_music (evc
, diff
)
1985 if diff
> Rational (0) and moment
== 0:
1986 self
.ignore_skips
= False
1988 def last_event_chord (self
, starting_at
):
1992 # if the position matches, find the last ChordEvent, do not cross a bar line!
1993 at
= len( self
.elements
) - 1
1995 not isinstance (self
.elements
[at
], musicexp
.ChordEvent
) and
1996 not isinstance (self
.elements
[at
], musicexp
.BarLine
)):
2001 and isinstance (self
.elements
[at
], musicexp
.ChordEvent
)
2002 and self
.begin_moment
== starting_at
):
2003 value
= self
.elements
[at
]
2005 self
.jumpto (starting_at
)
2009 def correct_negative_skip (self
, goto
):
2010 self
.end_moment
= goto
2011 self
.begin_moment
= goto
2012 evc
= musicexp
.ChordEvent ()
2013 self
.elements
.append (evc
)
2017 def __init__ (self
):
2018 self
.voicename
= None
2019 self
.voicedata
= None
2020 self
.ly_voice
= None
2021 self
.figured_bass
= None
2022 self
.chordnames
= None
2023 self
.lyrics_dict
= {}
2024 self
.lyrics_order
= []
2026 def musicxml_step_to_lily (step
):
2028 return (ord (step
) - ord ('A') + 7 - 2) % 7
2032 def measure_length_from_attributes (attr
, current_measure_length
):
2033 len = attr
.get_measure_length ()
2035 len = current_measure_length
2038 def musicxml_voice_to_lily_voice (voice
):
2042 return_value
= VoiceData ()
2043 return_value
.voicedata
= voice
2045 # First pitch needed for relative mode (if selected in command-line options)
2048 # Needed for melismata detection (ignore lyrics on those notes!):
2053 ignore_lyrics
= False
2055 current_staff
= None
2057 pending_figured_bass
= []
2058 pending_chordnames
= []
2060 # Make sure that the keys in the dict don't get reordered, since
2061 # we need the correct ordering of the lyrics stanzas! By default,
2062 # a dict will reorder its keys
2063 return_value
.lyrics_order
= voice
.get_lyrics_numbers ()
2064 for k
in return_value
.lyrics_order
:
2067 voice_builder
= LilyPondVoiceBuilder ()
2068 figured_bass_builder
= LilyPondVoiceBuilder ()
2069 chordnames_builder
= LilyPondVoiceBuilder ()
2070 current_measure_length
= Rational (4, 4)
2071 voice_builder
.set_measure_length (current_measure_length
)
2073 for n
in voice
._elements
:
2074 if n
.get_name () == 'forward':
2076 staff
= n
.get_maybe_exist_named_child ('staff')
2078 staff
= staff
.get_text ()
2079 if current_staff
and staff
<> current_staff
and not n
.get_maybe_exist_named_child ('chord'):
2080 voice_builder
.add_command (musicexp
.StaffChange (staff
))
2081 current_staff
= staff
2083 if isinstance (n
, musicxml
.Partial
) and n
.partial
> 0:
2084 a
= musicxml_partial_to_lily (n
.partial
)
2086 voice_builder
.add_partial (a
)
2089 is_chord
= n
.get_maybe_exist_named_child ('chord')
2090 is_after_grace
= (isinstance (n
, musicxml
.Note
) and n
.is_after_grace ());
2091 if not is_chord
and not is_after_grace
:
2093 voice_builder
.jumpto (n
._when
)
2094 except NegativeSkip
, neg
:
2095 voice_builder
.correct_negative_skip (n
._when
)
2096 n
.message (_ ("Negative skip found: from %s to %s, difference is %s") % (neg
.here
, neg
.dest
, neg
.dest
- neg
.here
))
2098 if isinstance (n
, musicxml
.Barline
):
2099 barlines
= musicxml_barline_to_lily (n
)
2101 if isinstance (a
, musicexp
.BarLine
):
2102 voice_builder
.add_barline (a
)
2103 elif isinstance (a
, RepeatMarker
) or isinstance (a
, EndingMarker
):
2104 voice_builder
.add_command (a
)
2107 # Continue any multimeasure-rests before trying to add bar checks!
2108 # Don't handle new MM rests yet, because for them we want bar checks!
2109 rest
= n
.get_maybe_exist_typed_child (musicxml
.Rest
)
2110 if (rest
and rest
.is_whole_measure ()
2111 and voice_builder
.pending_multibar
> Rational (0)):
2112 voice_builder
.add_multibar_rest (n
._duration
)
2116 # print a bar check at the beginning of each measure!
2117 if n
.is_first () and n
._measure
_position
== Rational (0) and n
!= voice
._elements
[0]:
2119 num
= int (n
.get_parent ().number
)
2123 voice_builder
.add_bar_check (num
)
2124 figured_bass_builder
.add_bar_check (num
)
2125 chordnames_builder
.add_bar_check (num
)
2127 # Start any new multimeasure rests
2128 if (rest
and rest
.is_whole_measure ()):
2129 voice_builder
.add_multibar_rest (n
._duration
)
2133 if isinstance (n
, musicxml
.Direction
):
2134 for a
in musicxml_direction_to_lily (n
):
2135 if a
.wait_for_note ():
2136 voice_builder
.add_dynamics (a
)
2138 voice_builder
.add_command (a
)
2141 if isinstance (n
, musicxml
.Harmony
):
2142 for a
in musicxml_harmony_to_lily (n
):
2143 if a
.wait_for_note ():
2144 voice_builder
.add_dynamics (a
)
2146 voice_builder
.add_command (a
)
2147 for a
in musicxml_harmony_to_lily_chordname (n
):
2148 pending_chordnames
.append (a
)
2151 if isinstance (n
, musicxml
.FiguredBass
):
2152 a
= musicxml_figured_bass_to_lily (n
)
2154 pending_figured_bass
.append (a
)
2157 if isinstance (n
, musicxml
.Attributes
):
2158 for a
in musicxml_attributes_to_lily (n
):
2159 voice_builder
.add_command (a
)
2160 measure_length
= measure_length_from_attributes (n
, current_measure_length
)
2161 if current_measure_length
!= measure_length
:
2162 current_measure_length
= measure_length
2163 voice_builder
.set_measure_length (current_measure_length
)
2166 if not n
.__class
__.__name
__ == 'Note':
2167 n
.message (_ ('unexpected %s; expected %s or %s or %s') % (n
, 'Note', 'Attributes', 'Barline'))
2170 main_event
= musicxml_note_to_lily_main_event (n
)
2171 if main_event
and not first_pitch
:
2172 first_pitch
= main_event
.pitch
2173 # ignore lyrics for notes inside a slur, tie, chord or beam
2174 ignore_lyrics
= inside_slur
or is_tied
or is_chord
or is_beamed
2176 if main_event
and hasattr (main_event
, 'drum_type') and main_event
.drum_type
:
2177 modes_found
['drummode'] = True
2179 ev_chord
= voice_builder
.last_event_chord (n
._when
)
2181 ev_chord
= musicexp
.ChordEvent()
2182 voice_builder
.add_music (ev_chord
, n
._duration
)
2185 grace
= n
.get_maybe_exist_typed_child (musicxml
.Grace
)
2187 is_after_grace
= ev_chord
.has_elements () or n
.is_after_grace ();
2188 is_chord
= n
.get_maybe_exist_typed_child (musicxml
.Chord
)
2192 # after-graces and other graces use different lists; Depending on
2193 # whether we have a chord or not, obtain either a new ChordEvent or
2194 # the previous one to create a chord
2196 if ev_chord
.after_grace_elements
and n
.get_maybe_exist_typed_child (musicxml
.Chord
):
2197 grace_chord
= ev_chord
.after_grace_elements
.get_last_event_chord ()
2199 grace_chord
= musicexp
.ChordEvent ()
2200 ev_chord
.append_after_grace (grace_chord
)
2202 if ev_chord
.grace_elements
and n
.get_maybe_exist_typed_child (musicxml
.Chord
):
2203 grace_chord
= ev_chord
.grace_elements
.get_last_event_chord ()
2205 grace_chord
= musicexp
.ChordEvent ()
2206 ev_chord
.append_grace (grace_chord
)
2208 if hasattr (grace
, 'slash') and not is_after_grace
:
2209 # TODO: use grace_type = "appoggiatura" for slurred grace notes
2210 if grace
.slash
== "yes":
2211 ev_chord
.grace_type
= "acciaccatura"
2212 # now that we have inserted the chord into the grace music, insert
2213 # everything into that chord instead of the ev_chord
2214 ev_chord
= grace_chord
2215 ev_chord
.append (main_event
)
2216 ignore_lyrics
= True
2218 ev_chord
.append (main_event
)
2219 # When a note/chord has grace notes (duration==0), the duration of the
2220 # event chord is not yet known, but the event chord was already added
2221 # with duration 0. The following correct this when we hit the real note!
2222 if voice_builder
.current_duration () == 0 and n
._duration
> 0:
2223 voice_builder
.set_duration (n
._duration
)
2225 # if we have a figured bass, set its voice builder to the correct position
2226 # and insert the pending figures
2227 if pending_figured_bass
:
2229 figured_bass_builder
.jumpto (n
._when
)
2230 except NegativeSkip
, neg
:
2232 for fb
in pending_figured_bass
:
2233 # if a duration is given, use that, otherwise the one of the note
2234 dur
= fb
.real_duration
2236 dur
= ev_chord
.get_length ()
2238 fb
.duration
= ev_chord
.get_duration ()
2239 figured_bass_builder
.add_music (fb
, dur
)
2240 pending_figured_bass
= []
2242 if pending_chordnames
:
2244 chordnames_builder
.jumpto (n
._when
)
2245 except NegativeSkip
, neg
:
2247 for cn
in pending_chordnames
:
2248 # Assign the duration of the EventChord
2249 cn
.duration
= ev_chord
.get_duration ()
2250 chordnames_builder
.add_music (cn
, ev_chord
.get_length ())
2251 pending_chordnames
= []
2253 notations_children
= n
.get_typed_children (musicxml
.Notations
)
2257 # The <notation> element can have the following children (+ means implemented, ~ partially, - not):
2258 # +tied | +slur | +tuplet | glissando | slide |
2259 # ornaments | technical | articulations | dynamics |
2260 # +fermata | arpeggiate | non-arpeggiate |
2261 # accidental-mark | other-notation
2262 for notations
in notations_children
:
2263 for tuplet_event
in notations
.get_tuplets():
2264 time_mod
= n
.get_maybe_exist_typed_child (musicxml
.Time_modification
)
2265 tuplet_events
.append ((ev_chord
, tuplet_event
, time_mod
))
2267 # First, close all open slurs, only then start any new slur
2268 # TODO: Record the number of the open slur to dtermine the correct
2270 endslurs
= [s
for s
in notations
.get_named_children ('slur')
2271 if s
.get_type () in ('stop')]
2272 if endslurs
and not inside_slur
:
2273 endslurs
[0].message (_ ('Encountered closing slur, but no slur is open'))
2275 if len (endslurs
) > 1:
2276 endslurs
[0].message (_ ('Cannot have two simultaneous (closing) slurs'))
2277 # record the slur status for the next note in the loop
2279 lily_ev
= musicxml_spanner_to_lily_event (endslurs
[0])
2280 ev_chord
.append (lily_ev
)
2282 startslurs
= [s
for s
in notations
.get_named_children ('slur')
2283 if s
.get_type () in ('start')]
2284 if startslurs
and inside_slur
:
2285 startslurs
[0].message (_ ('Cannot have a slur inside another slur'))
2287 if len (startslurs
) > 1:
2288 startslurs
[0].message (_ ('Cannot have two simultaneous slurs'))
2289 # record the slur status for the next note in the loop
2291 lily_ev
= musicxml_spanner_to_lily_event (startslurs
[0])
2292 ev_chord
.append (lily_ev
)
2296 mxl_tie
= notations
.get_tie ()
2297 if mxl_tie
and mxl_tie
.type == 'start':
2298 ev_chord
.append (musicexp
.TieEvent ())
2303 fermatas
= notations
.get_named_children ('fermata')
2305 ev
= musicxml_fermata_to_lily_event (a
)
2307 ev_chord
.append (ev
)
2309 arpeggiate
= notations
.get_named_children ('arpeggiate')
2310 for a
in arpeggiate
:
2311 ev
= musicxml_arpeggiate_to_lily_event (a
)
2313 ev_chord
.append (ev
)
2315 arpeggiate
= notations
.get_named_children ('non-arpeggiate')
2316 for a
in arpeggiate
:
2317 ev
= musicxml_nonarpeggiate_to_lily_event (a
)
2319 ev_chord
.append (ev
)
2321 glissandos
= notations
.get_named_children ('glissando')
2322 glissandos
+= notations
.get_named_children ('slide')
2323 for a
in glissandos
:
2324 ev
= musicxml_spanner_to_lily_event (a
)
2326 ev_chord
.append (ev
)
2328 # accidental-marks are direct children of <notation>!
2329 for a
in notations
.get_named_children ('accidental-mark'):
2330 ev
= musicxml_articulation_to_lily_event (a
)
2332 ev_chord
.append (ev
)
2334 # Articulations can contain the following child elements:
2335 # accent | strong-accent | staccato | tenuto |
2336 # detached-legato | staccatissimo | spiccato |
2337 # scoop | plop | doit | falloff | breath-mark |
2338 # caesura | stress | unstress
2339 # Technical can contain the following child elements:
2340 # up-bow | down-bow | harmonic | open-string |
2341 # thumb-position | fingering | pluck | double-tongue |
2342 # triple-tongue | stopped | snap-pizzicato | fret |
2343 # string | hammer-on | pull-off | bend | tap | heel |
2344 # toe | fingernails | other-technical
2345 # Ornaments can contain the following child elements:
2346 # trill-mark | turn | delayed-turn | inverted-turn |
2347 # shake | wavy-line | mordent | inverted-mordent |
2348 # schleifer | tremolo | other-ornament, accidental-mark
2349 ornaments
= notations
.get_named_children ('ornaments')
2350 ornaments
+= notations
.get_named_children ('articulations')
2351 ornaments
+= notations
.get_named_children ('technical')
2354 for ch
in a
.get_all_children ():
2355 ev
= musicxml_articulation_to_lily_event (ch
)
2357 ev_chord
.append (ev
)
2359 dynamics
= notations
.get_named_children ('dynamics')
2361 for ch
in a
.get_all_children ():
2362 ev
= musicxml_dynamics_to_lily_event (ch
)
2364 ev_chord
.append (ev
)
2367 mxl_beams
= [b
for b
in n
.get_named_children ('beam')
2368 if (b
.get_type () in ('begin', 'end')
2369 and b
.is_primary ())]
2370 if mxl_beams
and not conversion_settings
.ignore_beaming
:
2371 beam_ev
= musicxml_spanner_to_lily_event (mxl_beams
[0])
2373 ev_chord
.append (beam_ev
)
2374 if beam_ev
.span_direction
== -1: # beam and thus melisma starts here
2376 elif beam_ev
.span_direction
== 1: # beam and thus melisma ends here
2379 # Extract the lyrics
2380 if not rest
and not ignore_lyrics
:
2381 note_lyrics_processed
= []
2382 note_lyrics_elements
= n
.get_typed_children (musicxml
.Lyric
)
2383 for l
in note_lyrics_elements
:
2384 if l
.get_number () < 0:
2385 for k
in lyrics
.keys ():
2386 lyrics
[k
].append (musicxml_lyrics_to_text (l
))
2387 note_lyrics_processed
.append (k
)
2389 lyrics
[l
.number
].append(musicxml_lyrics_to_text (l
))
2390 note_lyrics_processed
.append (l
.number
)
2391 for lnr
in lyrics
.keys ():
2392 if not lnr
in note_lyrics_processed
:
2393 lyrics
[lnr
].append ("\skip4")
2395 ## force trailing mm rests to be written out.
2396 voice_builder
.add_music (musicexp
.ChordEvent (), Rational (0))
2398 ly_voice
= group_tuplets (voice_builder
.elements
, tuplet_events
)
2399 ly_voice
= group_repeats (ly_voice
)
2401 seq_music
= musicexp
.SequentialMusic ()
2403 if 'drummode' in modes_found
.keys ():
2404 ## \key <pitch> barfs in drummode.
2405 ly_voice
= [e
for e
in ly_voice
2406 if not isinstance(e
, musicexp
.KeySignatureChange
)]
2408 seq_music
.elements
= ly_voice
2409 for k
in lyrics
.keys ():
2410 return_value
.lyrics_dict
[k
] = musicexp
.Lyrics ()
2411 return_value
.lyrics_dict
[k
].lyrics_syllables
= lyrics
[k
]
2414 if len (modes_found
) > 1:
2415 error_message (_ ('cannot simultaneously have more than one mode: %s') % modes_found
.keys ())
2417 if options
.relative
:
2418 v
= musicexp
.RelativeMusic ()
2419 v
.element
= seq_music
2420 v
.basepitch
= first_pitch
2423 return_value
.ly_voice
= seq_music
2424 for mode
in modes_found
.keys ():
2425 v
= musicexp
.ModeChangingMusicWrapper()
2426 v
.element
= seq_music
2428 return_value
.ly_voice
= v
2430 # create \figuremode { figured bass elements }
2431 if figured_bass_builder
.has_relevant_elements
:
2432 fbass_music
= musicexp
.SequentialMusic ()
2433 fbass_music
.elements
= figured_bass_builder
.elements
2434 v
= musicexp
.ModeChangingMusicWrapper()
2435 v
.mode
= 'figuremode'
2436 v
.element
= fbass_music
2437 return_value
.figured_bass
= v
2439 # create \chordmode { chords }
2440 if chordnames_builder
.has_relevant_elements
:
2441 cname_music
= musicexp
.SequentialMusic ()
2442 cname_music
.elements
= chordnames_builder
.elements
2443 v
= musicexp
.ModeChangingMusicWrapper()
2444 v
.mode
= 'chordmode'
2445 v
.element
= cname_music
2446 return_value
.chordnames
= v
2450 def musicxml_id_to_lily (id):
2451 digits
= ['Zero', 'One', 'Two', 'Three', 'Four', 'Five',
2452 'Six', 'Seven', 'Eight', 'Nine', 'Ten']
2454 for digit
in digits
:
2455 d
= digits
.index (digit
)
2456 id = re
.sub ('%d' % d
, digit
, id)
2458 id = re
.sub ('[^a-zA-Z]', 'X', id)
2461 def musicxml_pitch_to_lily (mxl_pitch
):
2462 p
= musicexp
.Pitch ()
2463 p
.alteration
= mxl_pitch
.get_alteration ()
2464 p
.step
= musicxml_step_to_lily (mxl_pitch
.get_step ())
2465 p
.octave
= mxl_pitch
.get_octave () - 4
2468 def musicxml_unpitched_to_lily (mxl_unpitched
):
2470 step
= mxl_unpitched
.get_step ()
2472 p
= musicexp
.Pitch ()
2473 p
.step
= musicxml_step_to_lily (step
)
2474 octave
= mxl_unpitched
.get_octave ()
2476 p
.octave
= octave
- 4
2479 def musicxml_restdisplay_to_lily (mxl_rest
):
2481 step
= mxl_rest
.get_step ()
2483 p
= musicexp
.Pitch ()
2484 p
.step
= musicxml_step_to_lily (step
)
2485 octave
= mxl_rest
.get_octave ()
2487 p
.octave
= octave
- 4
2490 def voices_in_part (part
):
2491 """Return a Name -> Voice dictionary for PART"""
2493 part
.extract_voices ()
2494 voices
= part
.get_voices ()
2495 part_info
= part
.get_staff_attributes ()
2497 return (voices
, part_info
)
2499 def voices_in_part_in_parts (parts
):
2500 """return a Part -> Name -> Voice dictionary"""
2501 return dict([(p
.id, voices_in_part (p
)) for p
in parts
])
2504 def get_all_voices (parts
):
2505 all_voices
= voices_in_part_in_parts (parts
)
2508 all_ly_staffinfo
= {}
2509 for p
, (name_voice
, staff_info
) in all_voices
.items ():
2512 for n
, v
in name_voice
.items ():
2513 progress (_ ("Converting to LilyPond expressions..."))
2514 # musicxml_voice_to_lily_voice returns (lily_voice, {nr->lyrics, nr->lyrics})
2515 part_ly_voices
[n
] = musicxml_voice_to_lily_voice (v
)
2517 all_ly_voices
[p
] = part_ly_voices
2518 all_ly_staffinfo
[p
] = staff_info
2520 return (all_ly_voices
, all_ly_staffinfo
)
2523 def option_parser ():
2524 p
= ly
.get_option_parser (usage
= _ ("musicxml2ly [OPTION]... FILE.xml"),
2526 _ ("""Convert MusicXML from FILE.xml to LilyPond input.
2527 If the given filename is -, musicxml2ly reads from the command line.
2528 """), add_help_option
=False)
2530 p
.add_option("-h", "--help",
2532 help=_ ("show this help and exit"))
2534 p
.version
= ('''%prog (LilyPond) @TOPLEVEL_VERSION@\n\n'''
2536 _ ("""Copyright (c) 2005--2009 by
2537 Han-Wen Nienhuys <hanwen@xs4all.nl>,
2538 Jan Nieuwenhuizen <janneke@gnu.org> and
2539 Reinhold Kainhofer <reinhold@kainhofer.com>
2543 This program is free software. It is covered by the GNU General Public
2544 License and you are welcome to change it and/or distribute copies of it
2545 under certain conditions. Invoke as `%s --warranty' for more
2546 information.""") % 'lilypond')
2548 p
.add_option("--version",
2550 help=_ ("show version number and exit"))
2552 p
.add_option ('-v', '--verbose',
2553 action
= "store_true",
2555 help = _ ("be verbose"))
2557 p
.add_option ('', '--lxml',
2558 action
= "store_true",
2561 help = _ ("use lxml.etree; uses less memory and cpu time"))
2563 p
.add_option ('-z', '--compressed',
2564 action
= "store_true",
2565 dest
= 'compressed',
2567 help = _ ("input file is a zip-compressed MusicXML file"))
2569 p
.add_option ('-r', '--relative',
2570 action
= "store_true",
2573 help = _ ("convert pitches in relative mode (default)"))
2575 p
.add_option ('-a', '--absolute',
2576 action
= "store_false",
2578 help = _ ("convert pitches in absolute mode"))
2580 p
.add_option ('-l', '--language',
2581 metavar
= _ ("LANG"),
2583 help = _ ("use a different language file 'LANG.ly' and corresponding pitch names, e.g. 'deutsch' for deutsch.ly"))
2585 p
.add_option ('--nd', '--no-articulation-directions',
2586 action
= "store_false",
2588 dest
= "convert_directions",
2589 help = _ ("do not convert directions (^, _ or -) for articulations, dynamics, etc."))
2591 p
.add_option ('--nrp', '--no-rest-positions',
2592 action
= "store_false",
2594 dest
= "convert_rest_positions",
2595 help = _ ("do not convert exact vertical positions of rests"))
2597 p
.add_option ('--no-beaming',
2598 action
= "store_false",
2600 dest
= "convert_beaming",
2601 help = _ ("do not convert beaming information, use lilypond's automatic beaming instead"))
2603 p
.add_option ('-o', '--output',
2604 metavar
= _ ("FILE"),
2608 dest
= 'output_name',
2609 help = _ ("set output filename to FILE, stdout if -"))
2610 p
.add_option_group ('',
2612 _ ("Report bugs via %s")
2613 % 'http://post.gmane.org/post.php'
2614 '?group=gmane.comp.gnu.lilypond.bugs') + '\n')
2617 def music_xml_voice_name_to_lily_name (part_id
, name
):
2618 str = "Part%sVoice%s" % (part_id
, name
)
2619 return musicxml_id_to_lily (str)
2621 def music_xml_lyrics_name_to_lily_name (part_id
, name
, lyricsnr
):
2622 str = "Part%sVoice%sLyrics%s" % (part_id
, name
, lyricsnr
)
2623 return musicxml_id_to_lily (str)
2625 def music_xml_figuredbass_name_to_lily_name (part_id
, voicename
):
2626 str = "Part%sVoice%sFiguredBass" % (part_id
, voicename
)
2627 return musicxml_id_to_lily (str)
2629 def music_xml_chordnames_name_to_lily_name (part_id
, voicename
):
2630 str = "Part%sVoice%sChords" % (part_id
, voicename
)
2631 return musicxml_id_to_lily (str)
2633 def print_voice_definitions (printer
, part_list
, voices
):
2634 for part
in part_list
:
2636 nv_dict
= voices
.get (part_id
, {})
2637 for (name
, voice
) in nv_dict
.items ():
2638 k
= music_xml_voice_name_to_lily_name (part_id
, name
)
2639 printer
.dump ('%s = ' % k
)
2640 voice
.ly_voice
.print_ly (printer
)
2642 if voice
.chordnames
:
2643 cnname
= music_xml_chordnames_name_to_lily_name (part_id
, name
)
2644 printer
.dump ('%s = ' % cnname
)
2645 voice
.chordnames
.print_ly (printer
)
2647 for l
in voice
.lyrics_order
:
2648 lname
= music_xml_lyrics_name_to_lily_name (part_id
, name
, l
)
2649 printer
.dump ('%s = ' % lname
)
2650 voice
.lyrics_dict
[l
].print_ly (printer
)
2652 if voice
.figured_bass
:
2653 fbname
= music_xml_figuredbass_name_to_lily_name (part_id
, name
)
2654 printer
.dump ('%s = ' % fbname
)
2655 voice
.figured_bass
.print_ly (printer
)
2660 return dict ([(elt
,1) for elt
in l
]).keys ()
2662 # format the information about the staff in the form
2665 # [voiceid1, [lyricsid11, lyricsid12,...], figuredbassid1],
2666 # [voiceid2, [lyricsid21, lyricsid22,...], figuredbassid2],
2670 # raw_voices is of the form [(voicename, lyricsids, havefiguredbass)*]
2671 def format_staff_info (part_id
, staff_id
, raw_voices
):
2673 for (v
, lyricsids
, figured_bass
, chordnames
) in raw_voices
:
2674 voice_name
= music_xml_voice_name_to_lily_name (part_id
, v
)
2675 voice_lyrics
= [music_xml_lyrics_name_to_lily_name (part_id
, v
, l
)
2677 figured_bass_name
= ''
2679 figured_bass_name
= music_xml_figuredbass_name_to_lily_name (part_id
, v
)
2680 chordnames_name
= ''
2682 chordnames_name
= music_xml_chordnames_name_to_lily_name (part_id
, v
)
2683 voices
.append ([voice_name
, voice_lyrics
, figured_bass_name
, chordnames_name
])
2684 return [staff_id
, voices
]
2686 def update_score_setup (score_structure
, part_list
, voices
):
2688 for part_definition
in part_list
:
2689 part_id
= part_definition
.id
2690 nv_dict
= voices
.get (part_id
)
2692 error_message (_ ('unknown part in part-list: %s') % part_id
)
2695 staves
= reduce (lambda x
,y
: x
+ y
,
2696 [voice
.voicedata
._staves
.keys ()
2697 for voice
in nv_dict
.values ()],
2700 if len (staves
) > 1:
2702 staves
= uniq_list (staves
)
2705 thisstaff_raw_voices
= [(voice_name
, voice
.lyrics_order
, voice
.figured_bass
, voice
.chordnames
)
2706 for (voice_name
, voice
) in nv_dict
.items ()
2707 if voice
.voicedata
._start
_staff
== s
]
2708 staves_info
.append (format_staff_info (part_id
, s
, thisstaff_raw_voices
))
2710 thisstaff_raw_voices
= [(voice_name
, voice
.lyrics_order
, voice
.figured_bass
, voice
.chordnames
)
2711 for (voice_name
, voice
) in nv_dict
.items ()]
2712 staves_info
.append (format_staff_info (part_id
, None, thisstaff_raw_voices
))
2713 score_structure
.set_part_information (part_id
, staves_info
)
2715 # Set global values in the \layout block, like auto-beaming etc.
2716 def update_layout_information ():
2717 if not conversion_settings
.ignore_beaming
and layout_information
:
2718 layout_information
.set_context_item ('Score', 'autoBeaming = ##f')
2720 def print_ly_preamble (printer
, filename
):
2721 printer
.dump_version ()
2722 printer
.print_verbatim ('%% automatically converted from %s\n' % filename
)
2724 def print_ly_additional_definitions (printer
, filename
):
2725 if needed_additional_definitions
:
2727 printer
.print_verbatim ('%% additional definitions required by the score:')
2729 for a
in set(needed_additional_definitions
):
2730 printer
.print_verbatim (additional_definitions
.get (a
, ''))
2734 # Read in the tree from the given I/O object (either file or string) and
2735 # demarshall it using the classes from the musicxml.py file
2736 def read_xml (io_object
, use_lxml
):
2739 tree
= lxml
.etree
.parse (io_object
)
2740 mxl_tree
= musicxml
.lxml_demarshal_node (tree
.getroot ())
2743 from xml
.dom
import minidom
, Node
2744 doc
= minidom
.parse(io_object
)
2745 node
= doc
.documentElement
2746 return musicxml
.minidom_demarshal_node (node
)
2750 def read_musicxml (filename
, compressed
, use_lxml
):
2754 progress (_ ("Input is compressed, extracting raw MusicXML data from stdin") )
2755 z
= zipfile
.ZipFile (sys
.stdin
)
2757 progress (_ ("Input file %s is compressed, extracting raw MusicXML data") % filename
)
2758 z
= zipfile
.ZipFile (filename
, "r")
2759 container_xml
= z
.read ("META-INF/container.xml")
2760 if not container_xml
:
2762 container
= read_xml (StringIO
.StringIO (container_xml
), use_lxml
)
2765 rootfiles
= container
.get_maybe_exist_named_child ('rootfiles')
2768 rootfile_list
= rootfiles
.get_named_children ('rootfile')
2770 if len (rootfile_list
) > 0:
2771 mxml_file
= getattr (rootfile_list
[0], 'full-path', None)
2773 raw_string
= z
.read (mxml_file
)
2776 io_object
= StringIO
.StringIO (raw_string
)
2777 elif filename
== "-":
2778 io_object
= sys
.stdin
2780 io_object
= filename
2782 return read_xml (io_object
, use_lxml
)
2785 def convert (filename
, options
):
2787 progress (_ ("Reading MusicXML from Standard input ...") )
2789 progress (_ ("Reading MusicXML from %s ...") % filename
)
2791 tree
= read_musicxml (filename
, options
.compressed
, options
.use_lxml
)
2792 score_information
= extract_score_information (tree
)
2793 paper_information
= extract_paper_information (tree
)
2795 parts
= tree
.get_typed_children (musicxml
.Part
)
2796 (voices
, staff_info
) = get_all_voices (parts
)
2799 mxl_pl
= tree
.get_maybe_exist_typed_child (musicxml
.Part_list
)
2801 score
= extract_score_structure (mxl_pl
, staff_info
)
2802 part_list
= mxl_pl
.get_named_children ("score-part")
2804 # score information is contained in the <work>, <identification> or <movement-title> tags
2805 update_score_setup (score
, part_list
, voices
)
2806 # After the conversion, update the list of settings for the \layout block
2807 update_layout_information ()
2809 if not options
.output_name
:
2810 options
.output_name
= os
.path
.basename (filename
)
2811 options
.output_name
= os
.path
.splitext (options
.output_name
)[0]
2812 elif re
.match (".*\.ly", options
.output_name
):
2813 options
.output_name
= os
.path
.splitext (options
.output_name
)[0]
2816 #defs_ly_name = options.output_name + '-defs.ly'
2817 if (options
.output_name
== "-"):
2818 output_ly_name
= 'Standard output'
2820 output_ly_name
= options
.output_name
+ '.ly'
2822 progress (_ ("Output to `%s'") % output_ly_name
)
2823 printer
= musicexp
.Output_printer()
2824 #progress (_ ("Output to `%s'") % defs_ly_name)
2825 if (options
.output_name
== "-"):
2826 printer
.set_file (codecs
.getwriter ("utf-8")(sys
.stdout
))
2828 printer
.set_file (codecs
.open (output_ly_name
, 'wb', encoding
='utf-8'))
2829 print_ly_preamble (printer
, filename
)
2830 print_ly_additional_definitions (printer
, filename
)
2831 if score_information
:
2832 score_information
.print_ly (printer
)
2833 if paper_information
:
2834 paper_information
.print_ly (printer
)
2835 if layout_information
:
2836 layout_information
.print_ly (printer
)
2837 print_voice_definitions (printer
, part_list
, voices
)
2840 printer
.dump ("% The score definition")
2842 score
.print_ly (printer
)
2847 def get_existing_filename_with_extension (filename
, ext
):
2848 if os
.path
.exists (filename
):
2850 newfilename
= filename
+ "." + ext
2851 if os
.path
.exists (newfilename
):
2853 newfilename
= filename
+ ext
2854 if os
.path
.exists (newfilename
):
2859 opt_parser
= option_parser()
2862 (options
, args
) = opt_parser
.parse_args ()
2864 opt_parser
.print_usage()
2867 if options
.language
:
2868 musicexp
.set_pitch_language (options
.language
)
2869 needed_additional_definitions
.append (options
.language
)
2870 additional_definitions
[options
.language
] = "\\include \"%s.ly\"\n" % options
.language
2871 conversion_settings
.ignore_beaming
= not options
.convert_beaming
2873 # Allow the user to leave out the .xml or xml on the filename
2874 basefilename
= args
[0].decode('utf-8')
2875 if basefilename
== "-": # Read from stdin
2878 filename
= get_existing_filename_with_extension (basefilename
, "xml")
2880 filename
= get_existing_filename_with_extension (basefilename
, "mxl")
2881 options
.compressed
= True
2882 if filename
and filename
.endswith ("mxl"):
2883 options
.compressed
= True
2885 if filename
and (filename
== "-" or os
.path
.exists (filename
)):
2886 voices
= convert (filename
, options
)
2888 progress (_ ("Unable to find input file %s") % basefilename
)
2890 if __name__
== '__main__':