Voice stealing does not apply to scheduled notes

[bdbarnett]

Stealing runs at press time and a scheduled press has not happened yet, so a
bar laid ahead can exceed the voice ceiling with nothing stolen.

From #91.

[bdbarnett]

Measured, and left open: the fix is engine-side and not this repository's.

It is deliberate, and the reason is written at the site. Keys.press stages a scheduled note before handing it to the queue, "so note in keys.pressed is true on the line after this one whether or not the queue took the event. press_voice() reads that answer to decide whether to steal a voice, and stealing from a future that has not happened yet would be worse than the dropped note." That is right. At schedule time the engine's occupancy at the future frame is unknowable, and press_voice's own docstring already records that every capacity figure available lies — max_polyphony is the wrong denominator once notes-per-key varies with a macro, and len(synth.pressed) has been measured reporting 0 while a fresh press was refused. A Python-side prediction here would be that same lie, one layer further from the truth.

But the exposure is real and easy to reach. Two bars through the sequencer and the pump at the 64 ceiling, CPython at AUDIODSP_PIN 4e58091, counting presses the engine turned away at apply time:

bar	peak voices	refused, silently
tr808, every circuit on every sixteenth	64 of 64	0
juno106, 4-note chords, 4-step gate	64 of 64	0
juno106, 8-note chords, 8-step gate	64 of 64	488
solina (ensemble voice), 8-note chords	64 of 64	1976

So the drum machine's own bar is safe — it sits exactly at the ceiling and never loses a note — and a held-chord part one step richer loses hundreds.

And nothing counts them, not even the pump. audiopump_events.c:126 discards the answer:

(void)synthio_span_change_note(&synth->synth, SYNTHIO_SILENCE, e->arg);

Events.stats()'s refused counts only a target that went away (audiopump_events.c:85, "refused at apply: the target went away"), so a press the engine turns down is invisible on both sides of the seam. That is the same silence as #26, one layer down, and #26's ruling puts it where it belongs: the engine is where a refusal is counted, and audiodsp is not this lane's to change.

So the useful next step is the engine-side counter, not a stealing layer in Python — which is also what Brad ruled for #26. Leaving this open for that. Nothing in audioinstruments or audiocomponents was changed for it.

Method: Sequencer driving a real audioinstruments instrument through the pump's event queue, synthio.Synthesizer.press wrapped with the twin's own refusal predicate (a press that admits no note and was not a re-press), 200 BPM, 16 steps, ahead=8, queue capacity 4096 so nothing is lost at the door.

[bdbarnett]

Arthur: this is the engine's to count before the library can act on it — folded into audiodsp#127 (the refused counter): the scheduled-press path through audiopump_events.c:126 must count a refusal the same way a live press does. The numbers here (juno106 488, solina 1976) are the material for that gate. Stays open until the counter exists.

[bdbarnett]

The audiodsp side of this is in PyDevices/audiodsp#137 (audiodsp#127): synthio.Synthesizer.refused, and it answers for a scheduled press as well as a live one.

That mattered more than the issue there assumed. audiopump_apply_press discarded what synthio_span_change_note returned, so a press applied from an Events queue with every channel held left no trace at all — which is the 488 presses on juno106 and 1976 on solina.

No second counter was needed: the count went into change_note rather than into press(), and change_note is the choke point both paths come through. So the instrument layer reads one number whichever way its notes arrive:

synth.refused        # presses dropped for want of a channel, live or scheduled

One distinction worth carrying into the measurement here, because two numbers with the same name will otherwise get added together: Events.stats()'s own refused counts events that could not be applied at all — a deinited target, a voice with no Mixer. synth.refused counts an event that applied perfectly and had nowhere to put its note. They are different failures and only the second is a note nobody hears.

Gated in route_probe.py's new refused case: more scheduled presses than channels, never released, and the counter must read exactly the overflow while the queue reports every event applied. --fault deaf zeroes the reading so the row fails.

For the re-measurement on this side: once #137 lands, the wrapper around press can go and the number comes off the synthesizer directly, for both the live and the sequenced runs.

[bdbarnett]

PR: #104 — the library's decision is refuse, and surface the count.

Not steal at schedule time, for the reason this issue already established and which is now written at Instrument.refused: the occupancy at a future frame is unknowable, and every number available to guess with lies. A Python-side prediction would be that same lie one layer further from the truth.

Sequencer.health() carries it as unvoiced — a deliberately different name, beside refused and never added to it, because audiodsp#137's warning about two numbers with one name was worth taking seriously.

Re-measured on the real pump with #137's counter, the wrapper around press gone, two bars at 200 BPM at the 64 ceiling:

bar	refused (queue)	unvoiced (engine)
tr808, every circuit on every sixteenth	0	0
juno106, 4-note chords, 4-step gate	0	0
juno106, 8-note chords, 8-step gate	0	488
solina, 8-note chords, 8-step gate	1520	1796

488 exactly, off synth.refused rather than off a predicate wrapped around press. The first two rows are the controls that must read zero.

The solina row is the better argument than anything I could write for keeping the two apart: 1520 events never reached the engine, and 1796 that did had nowhere to put their note. It reads 1796 here against this issue's 1976 because 1520 fewer presses got through the door — the same measurement seen from both sides at once.

None rather than 0 where the engine cannot count. Verified as a natural experiment against the installed audiodsp 0.4.0, which predates #137: every level reads None while refused still reads 0, which is the honest pair.

Instrument.refused sums over an instrument's keyboards, so acoustickit's two synthesizers count as one instrument.

Same pin caveat as #94: AUDIODSP_PIN 4e58091 predates #137, so CI's engine cannot count and unvoiced reads None there. The tests hold either way — they prove the plumbing and the separation against stand-ins, and the numbers above are the workspace-local measurement.

[bdbarnett]

Closed. #104 is merged (d449401), and these numbers are re-measured against main as it now stands rather than against the branch.

The library's decision is to refuse and surface the count, not to steal at schedule time. The reasoning is this issue's own and it is now written at Instrument.refused: the occupancy at a future frame is unknowable, and every number available to guess with lies — max_polyphony is the wrong denominator once notes-per-key varies with a macro, and len(synth.pressed) has been measured reading 0 while a fresh press was refused. A Python-side prediction would be that same lie one layer further from the truth.

Three readers, all live on main:

keys.refused        # one keyboard
inst.refused        # summed over an instrument's keyboards -- acoustickit has two
seq.health()["unvoiced"]

unvoiced, deliberately not refused, because audiodsp#137's warning about two numbers with one name was worth taking seriously. health()["refused"] is the queue turning an event away at the door: nothing was applied. health()["unvoiced"] is an event that applied perfectly and found every channel held.

Two bars of the sequencer at 200 BPM through the real pump, at the 64-voice ceiling, with the wrapper around press gone and the number read off synth.refused:

bar	refused (queue)	unvoiced (engine)
tr808, every circuit on every sixteenth	0	0
juno106, 4-note chords, 4-step gate	0	0
juno106, 8-note chords, 8-step gate	0	488
solina, 8-note chords, 8-step gate	1520	1796

488 exactly, the number this issue opened with, now off the engine's own counter instead of a predicate wrapped around press. The first two rows are the controls that have to read zero, and do.

The solina row is a better argument than anything I could write for keeping the two apart: 1520 events never reached the engine at all, and 1796 that did had nowhere to put their note. It reads 1796 here against this issue's original 1976 because 1520 fewer presses got through the door — the same bar seen from both sides at once, which is precisely why adding them would produce a number that means nothing.

None rather than 0 where the engine cannot count. An engine that cannot say is not an engine that lost nothing. Verified as a natural experiment against the installed audiodsp 0.4.0, which predates audiodsp#137: every level reads None while refused still reads 0, which is the honest pair. The tests hold either way — they prove the plumbing and the separation against stand-ins, so they do not quietly change meaning when AUDIODSP_PIN moves.

Nothing is left on this side. What an app does with the number — a warning, a voice-count readout, a thinner patch — is an app's decision, and it can now be made.