Variable mute for gangsa. Intended for the inst_postproc field. This interprets Controls.mute and turns it into either a %mod control or mute_attr.

There are 4 ways to realize a kotekan:

1. Undivided. Since it's undivided it could be unison or kempyung.
2. Slow but divided. Play all the notes, but sangsih and polos are kempyung on the outer notes. 3, 4. Ngotek, in telu and pat versions.

Initially I implemented this as a postproc, but it now seems to me that it would be more convenient as a generator. In any case, as a postproc it gets really complicated.

Realize the output of norot_sequence.

Figure out the appropriate cycles for each norot phase. There are 3 phases: an optional preparation for the current pitch, a variable length sustain, and an optional preparation for the next pitch.

Figure out parameters for the sustain and prepare phases. Why is this SO COMPLICATED.

TODO this is still used by Reyong. If I can simplify reyong norot too then I can get rid of it.

For regular kotekan, the sangsih can be automatically derived from the polos.

Take a Cycle, which is an abstract description of a pattern via KotekanNotes, to real notes in a NoteDeriver.

Make both parts end on zero by subtracting the pitch of the final non-interlocking note.

Find a kernel as a rotation or inversion of one of the standard ones.

(interlocking pattern, non-interlocking pattern)

Each list represents coincident notes. [] is a rest.

High level description of a note. This goes into Note before it becomes a Derive.NoteDeriver.

Repeatedly call a cycle generating function to create notes. The result will presumably be passed to realize_notes to convert the notes into NoteDerivers.

Pair each t with an a, asking the function for more as as needed.

This is like cycles, but the last cycle is aligned to the end of the ts, chopping off the front of the cycle if necessary.

Like zip, but two sequences are aligned at at their ends, instead of their starts.

Turn Notes into a NoteDeriver.

Style for non-interlocking norot. Interlocking norot is always the upper neighbor (or lower on the top key).

I could do this in two different ways: Eval normally, then eval with +kempyung, and make instrument note call understand it. Or, postproc, transpose, and check if the nn is above a limit. The first one would let the instrument choose how it wants to interpret +kempyung while letting this call remain generic, but let's face it, it only really means one thing. The second seems a little simpler since it doesn't need a cooperating note call.

So postproc it is.

(noltol-time, kotekan-dur, damp-dyn)

If the next note of the same instrument is below a threshold, the note's off time is replaced with a +mute.

Kotekan ends with a final, which cancels normal, but loses to strong. This is like Postproc.cancel_strong_weak, except it adds final_flag, so I can have the end of a kotekan override, but still be overidden with an explicit strong note.

Match any of polos, sangsih, and pasang to each other. Since polos and sangsih together are considered one voice, a sangsih start is note end for a polos note.

Get pitch for a kotekan call.