;;;; This file is part of LilyPond, the GNU music typesetter.
;;;;
-;;;; Copyright (C) 2004--2014 Han-Wen Nienhuys <hanwen@xs4all.nl>
+;;;; Copyright (C) 2004--2015 Han-Wen Nienhuys <hanwen@xs4all.nl>
;;;;
;;;; LilyPond is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
(ly:in-event-class? x 'note-event))
(filter f? (events vs)))
+; Return a list of note events which is sorted and stripped of
+; properties that we do not want to prevent combining parts.
+(define-method (comparable-note-events (vs <Voice-state>))
+ (define (note<? note1 note2)
+ (let ((p1 (ly:event-property note1 'pitch))
+ (p2 (ly:event-property note2 'pitch)))
+ (cond ((ly:pitch<? p1 p2) #t)
+ ((ly:pitch<? p2 p1) #f)
+ (else (ly:duration<? (ly:event-property note1 'duration)
+ (ly:event-property note2 'duration))))))
+ ;; TODO we probably should compare articulations too
+ (sort (map (lambda (x)
+ (ly:make-stream-event
+ (ly:make-event-class 'note-event)
+ (list (cons 'duration (ly:event-property x 'duration))
+ (cons 'pitch (ly:event-property x 'pitch)))))
+ (note-events vs))
+ note<?))
+
+(define-method (rest-and-skip-events (vs <Voice-state>))
+ (define (f? x)
+ (or (ly:in-event-class? x 'rest-event)
+ (ly:in-event-class? x 'skip-event)))
+ (filter f? (events vs)))
+
+(define-method (any-mmrest-events (vs <Voice-state>))
+ (define (f? x)
+ (ly:in-event-class? x 'multi-measure-rest-event))
+ (any f? (events vs)))
+
(define-method (previous-voice-state (vs <Voice-state>))
(let ((i (slot-ref vs 'vector-index))
(v (slot-ref vs 'state-vector)))
(display " synced "))
(display "\n" f))
+(define-method (current-or-previous-voice-states (ss <Split-state>))
+ "Return voice states meeting the following conditions. For a voice
+in sync, return the current voice state. For a voice out of sync,
+return the previous voice state."
+ (let* ((vss (voice-states ss))
+ (vs1 (car vss))
+ (vs2 (cdr vss)))
+ (if (and vs1 (not (equal? (moment vs1) (moment ss))))
+ (set! vs1 (previous-voice-state vs1)))
+ (if (and vs2 (not (equal? (moment vs2) (moment ss))))
+ (set! vs2 (previous-voice-state vs2)))
+ (cons vs1 vs2)))
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(if (< result-idx (vector-length result))
(let* ((now-state (vector-ref result result-idx)) ; current result
;; Extract all part-combine force events
- (ev1 (part-combine-events (car (voice-states now-state))))
- (ev2 (part-combine-events (cdr (voice-states now-state))))
- (evts (append ev1 ev2))
+ (evts (if (synced? now-state)
+ (append
+ (part-combine-events (car (voice-states now-state)))
+ (part-combine-events (cdr (voice-states now-state))))
+ '()))
;; result is (once-state permament-state):
(state (fold forced-result (cons 'automatic prev-res) evts))
;; Now let once override permanent changes:
(define (analyse-notes now-state)
(let* ((vs1 (car (voice-states now-state)))
(vs2 (cdr (voice-states now-state)))
- (notes1 (note-events vs1))
- (durs1 (sort (map (lambda (x) (ly:event-property x 'duration))
- notes1)
- ly:duration<?))
- (pitches1 (sort (map (lambda (x) (ly:event-property x 'pitch))
- notes1)
- ly:pitch<?))
- (notes2 (note-events vs2))
- (durs2 (sort (map (lambda (x) (ly:event-property x 'duration))
- notes2)
- ly:duration<?))
- (pitches2 (sort (map (lambda (x) (ly:event-property x 'pitch))
- notes2)
- ly:pitch<?)))
- (cond ((> (length notes1) 1) (put 'apart))
- ((> (length notes2) 1) (put 'apart))
- ((= 1 (+ (length notes2) (length notes1))) (put 'apart))
- ((and (= (length durs1) 1)
- (= (length durs2) 1)
- (not (equal? (car durs1) (car durs2))))
- (put 'apart))
- (else
- (if (and (= (length pitches1) (length pitches2)))
- (if (and (pair? pitches1)
- (pair? pitches2)
- ; Is the interval outside of chord-range?
- (let ((diff (ly:pitch-steps
- (ly:pitch-diff (car pitches1)
- (car pitches2)))))
- (or (< diff chord-min-diff)
- (> diff chord-max-diff)
- )))
- (put 'apart)
- ;; copy previous split state from spanner state
- (begin
- (if (previous-voice-state vs1)
- (copy-state-from voice-state-vec1
- (previous-voice-state vs1)))
- (if (previous-voice-state vs2)
- (copy-state-from voice-state-vec2
- (previous-voice-state vs2)))
- (if (and (null? (span-state vs1)) (null? (span-state vs2)))
- (put 'chords)))))))))
+ (notes1 (comparable-note-events vs1))
+ (notes2 (comparable-note-events vs2)))
+ (cond
+ ;; if neither part has notes, do nothing
+ ((and (not (pair? notes1)) (not (pair? notes2))))
+
+ ;; if one part has notes and the other does not
+ ((or (not (pair? notes1)) (not (pair? notes2))) (put 'apart))
+
+ ;; if either part has a chord
+ ((or (> (length notes1) 1)
+ (> (length notes2) 1))
+ (if (and (<= chord-min-diff 0) ; user requests combined unisons
+ (equal? notes1 notes2)) ; both parts have the same chord
+ (put 'chords)
+ (put 'apart)))
+
+ ;; if the durations are different
+ ;; TODO articulations too?
+ ((and (not (equal? (ly:event-property (car notes1) 'duration)
+ (ly:event-property (car notes2) 'duration))))
+ (put 'apart))
+
+ (else
+ ;; Is the interval outside of chord-range?
+ (if (let ((diff (ly:pitch-steps
+ (ly:pitch-diff
+ (ly:event-property (car notes1) 'pitch)
+ (ly:event-property (car notes2) 'pitch)))))
+ (or (< diff chord-min-diff)
+ (> diff chord-max-diff)
+ ))
+ (put 'apart)
+ ;; copy previous split state from spanner state
+ (begin
+ (if (previous-voice-state vs1)
+ (copy-state-from voice-state-vec1
+ (previous-voice-state vs1)))
+ (if (previous-voice-state vs2)
+ (copy-state-from voice-state-vec2
+ (previous-voice-state vs2)))
+ (if (and (null? (span-state vs1)) (null? (span-state vs2)))
+ (put 'chords))))))))
(if (< result-idx (vector-length result))
(let* ((now-state (vector-ref result result-idx))
(let* ((now-state (vector-ref result result-idx))
(vs1 (car (voice-states now-state)))
(vs2 (cdr (voice-states now-state))))
- (if (and (equal? (configuration now-state) 'chords)
- vs1 vs2)
- (let ((notes1 (note-events vs1))
- (notes2 (note-events vs2)))
- (cond ((and (= 1 (length notes1))
- (= 1 (length notes2))
- (equal? (ly:event-property (car notes1) 'pitch)
- (ly:event-property (car notes2) 'pitch)))
+
+ (define (analyse-synced-silence)
+ (let ((rests1 (if vs1 (rest-and-skip-events vs1) '()))
+ (rests2 (if vs2 (rest-and-skip-events vs2) '())))
+ (cond
+
+ ;; multi-measure rests (probably), which the
+ ;; part-combine iterator handles well
+ ((and (= 0 (length rests1))
+ (= 0 (length rests2)))
+ (set! (configuration now-state) 'unisilence))
+
+ ;; equal rests or equal skips, but not one of each
+ ((and (= 1 (length rests1))
+ (= 1 (length rests2))
+ (equal? (ly:event-property (car rests1) 'class)
+ (ly:event-property (car rests2) 'class))
+ (equal? (ly:event-property (car rests1) 'duration)
+ (ly:event-property (car rests2) 'duration)))
+ (set! (configuration now-state) 'unisilence))
+
+ ;; rests of different durations or mixed with
+ ;; skips or multi-measure rests
+ (else
+ ;; TODO For skips, route the rest to the shared
+ ;; voice and the skip to the voice for its part?
+ (set! (configuration now-state) 'apart-silence))
+
+ )))
+
+ (define (analyse-unsynced-silence vs1 vs2)
+ (let ((any-mmrests1 (if vs1 (any-mmrest-events vs1) #f))
+ (any-mmrests2 (if vs2 (any-mmrest-events vs2) #f)))
+ (cond
+ ;; If a multi-measure rest begins now while the other
+ ;; part has an ongoing multi-measure rest (or has
+ ;; ended), start displaying the one that begins now.
+ ((and any-mmrests1
+ (equal? (moment vs1) (moment now-state))
+ (or (not vs2) any-mmrests2))
+ (set! (configuration now-state) 'silence1))
+
+ ;; as above with parts swapped
+ ((and any-mmrests2
+ (equal? (moment vs2) (moment now-state))
+ (or (not vs1) any-mmrests1))
+ (set! (configuration now-state) 'silence2))
+ )))
+
+ (if (or vs1 vs2)
+ (let ((notes1 (if vs1 (comparable-note-events vs1) '()))
+ (notes2 (if vs2 (comparable-note-events vs2) '())))
+ (cond ((and (equal? (configuration now-state) 'chords)
+ (pair? notes1)
+ (equal? notes1 notes2))
(set! (configuration now-state) 'unisono))
- ((and (= 0 (length notes1))
- (= 0 (length notes2)))
- (set! (configuration now-state) 'unisilence)))))
+
+ ((synced? now-state)
+ (if (and (= 0 (length notes1))
+ (= 0 (length notes2)))
+ (analyse-synced-silence)))
+
+ (else ;; not synchronized
+ (let* ((vss
+ (current-or-previous-voice-states now-state))
+ (vs1 (car vss))
+ (vs2 (cdr vss)))
+ (if (and
+ (or (not vs1) (= 0 (length (note-events vs1))))
+ (or (not vs2) (= 0 (length (note-events vs2)))))
+ (analyse-unsynced-silence vs1 vs2))))
+ )))
(analyse-a2 (1+ result-idx)))))
(define (analyse-solo12 result-idx)
;; try-solo
start-idx))
- (define (analyse-moment result-idx)
+ (define (analyse-apart-silence result-idx)
+ "Analyse 'apart-silence starting at RESULT-IDX. Return next index."
+ (let* ((now-state (vector-ref result result-idx))
+ (vs1 (current-voice-state now-state 1))
+ (vs2 (current-voice-state now-state 2))
+ (rests1 (if vs1 (rest-and-skip-events vs1) '()))
+ (rests2 (if vs2 (rest-and-skip-events vs2) '()))
+ (prev-state (if (> result-idx 0)
+ (vector-ref result (- result-idx 1))
+ #f))
+ (prev-config (if prev-state
+ (configuration prev-state)
+ 'apart-silence)))
+ (cond
+ ;; rest with multi-measure rest: choose the rest
+ ((and (synced? now-state)
+ (= 1 (length rests1))
+ (ly:in-event-class? (car rests1) 'rest-event)
+ (= 0 (length rests2))) ; probably mmrest
+ (put 'silence1))
+
+ ;; as above with parts swapped
+ ((and (synced? now-state)
+ (= 1 (length rests2))
+ (ly:in-event-class? (car rests2) 'rest-event)
+ (= 0 (length rests1))) ; probably mmrest
+ (put 'silence2))
+
+ ((synced? now-state)
+ (put 'apart-silence))
+
+ ;; remain in the silence1/2 states until resync
+ ((equal? prev-config 'silence1)
+ (put 'silence1))
+
+ ((equal? prev-config 'silence2)
+ (put 'silence2))
+
+ (else
+ (put 'apart-silence)))
+
+ (1+ result-idx)))
+
+ (define (analyse-apart result-idx)
"Analyse 'apart starting at RESULT-IDX. Return next index."
(let* ((now-state (vector-ref result result-idx))
(vs1 (current-voice-state now-state 1))
(max
;; we should always increase.
(cond ((and (= n1 0) (= n2 0))
- (put 'apart-silence)
- (1+ result-idx))
+ ;; If we hit this, it means that the previous passes
+ ;; have designated as 'apart what is really
+ ;; 'apart-silence.
+ (analyse-apart-silence result-idx))
((and (= n2 0)
(equal? (moment vs1) (moment now-state))
(null? (previous-span-state vs1)))
(1+ result-idx))))
(if (< result-idx (vector-length result))
- (if (equal? (configuration (vector-ref result result-idx)) 'apart)
- (analyse-solo12 (analyse-moment result-idx))
- (analyse-solo12 (1+ result-idx))))) ; analyse-solo12
+ (let ((conf (configuration (vector-ref result result-idx))))
+ (cond
+ ((equal? conf 'apart)
+ (analyse-solo12 (analyse-apart result-idx)))
+ ((equal? conf 'apart-silence)
+ (analyse-solo12 (analyse-apart-silence result-idx)))
+ (else
+ (analyse-solo12 (1+ result-idx))))))) ; analyse-solo12
(analyse-spanner-states voice-state-vec1)
(analyse-spanner-states voice-state-vec2)
(display result))
result))
+(define-public default-part-combine-mark-state-machine
+ ;; (current-state . ((split-state-event .
+ ;; (output-voice output-event next-state)) ...))
+ '((Initial . ((solo1 . (solo SoloOneEvent Solo1))
+ (solo2 . (solo SoloTwoEvent Solo2))
+ (unisono . (shared UnisonoEvent Unisono))))
+ (Solo1 . ((apart . (#f #f Initial))
+ (chords . (#f #f Initial))
+ (solo2 . (solo SoloTwoEvent Solo2))
+ (unisono . (shared UnisonoEvent Unisono))))
+ (Solo2 . ((apart . (#f #f Initial))
+ (chords . (#f #f Initial))
+ (solo1 . (solo SoloOneEvent Solo1))
+ (unisono . (shared UnisonoEvent Unisono))))
+ (Unisono . ((apart . (#f #f Initial))
+ (chords . (#f #f Initial))
+ (solo1 . (solo SoloOneEvent Solo1))
+ (solo2 . (solo SoloTwoEvent Solo2))))))
+
+(define-public (make-part-combine-marks state-machine split-list)
+ "Generate a sequence of part combiner events from a split list"
+
+ (define (get-state state-name)
+ (assq-ref state-machine state-name))
+
+ (let ((full-seq '()) ; sequence of { \context Voice = "x" {} ... }
+ (segment '()) ; sequence within \context Voice = "x" {...}
+ (prev-moment ZERO-MOMENT)
+ (prev-voice #f)
+ (state (get-state 'Initial)))
+
+ (define (commit-segment)
+ "Add the current segment to the full sequence and begin another."
+ (if (pair? segment)
+ (set! full-seq
+ (cons (make-music 'ContextSpeccedMusic
+ 'context-id (symbol->string prev-voice)
+ 'context-type 'Voice
+ 'element (make-sequential-music (reverse! segment)))
+ full-seq)))
+ (set! segment '()))
+
+ (define (handle-split split)
+ (let* ((moment (car split))
+ (action (assq-ref state (cdr split))))
+ (if action
+ (let ((voice (car action))
+ (part-combine-event (cadr action))
+ (next-state-name (caddr action)))
+ (if part-combine-event
+ (let ((dur (ly:moment-sub moment prev-moment)))
+ ;; start a new segment when the voice changes
+ (if (not (eq? voice prev-voice))
+ (begin
+ (commit-segment)
+ (set! prev-voice voice)))
+ (if (not (equal? dur ZERO-MOMENT))
+ (set! segment (cons (make-music 'SkipEvent
+ 'duration (make-duration-of-length dur)) segment)))
+ (set! segment (cons (make-music part-combine-event) segment))
+
+ (set! prev-moment moment)))
+ (set! state (get-state next-state-name))))))
+
+ (for-each handle-split split-list)
+ (commit-segment)
+ (make-sequential-music (reverse! full-seq))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;