Keep a round every millisecond minimised or not; quiet the outputs before STOP waits on the driver; let an outage let go of the rig; drop presses made while stopped

- The output thread's rounds keep to a 1 ms grid on a high-resolution waitable timer. Measured on
  the exe: 1016 to 1034 wake-ups a second with the window normal, minimised and covered, where
  1.3.2 made 684 to 689 (every wait Windows offers ends a timer tick late, and a wait timed from
  the end of a round added that tick to every round). And the process opts out of Windows' power
  throttling at startup, both kinds, so Windows 11 keeps its timer requests and its speed while
  the window is minimised or covered. The console does the same.
- STOP posts to the outputs before it stops the tracker, and quitting does too: the tracker's stop
  waits on the driver, and the outputs went on firing the beats they predicted meanwhile.
- An input outage tells the outputs, which let go of the rig as the input going quiet does: the
  lasers disarmed, every held note and clip released, held fires dropped, nothing predicted from
  the last beats, Link snapped again on the next lock. An unplugged interface sends no audio at
  all, so the tracker never heard a silence, and the lasers held their last clip through it.
- ÷2, ×2, a tap, a pin or DOWNBEAT pressed on a control surface while stopped is dropped at
  START: START applied them to the run that had ended, and a tap moved the next run's BPM window.
  A setting is never refused by a queue full of presses — the oldest press gives way — so the
  latency and window sliders always reach the tracker. The console's --hold-bpm is posted after
  its tracker starts, where START no longer lets go of it.
- RtMidi's errors go to a callback and are thrown after the call as before, instead of being
  written to stderr — takt4.log beside the executable, unbuffered — on the output thread every
  round while a pulled-out device failed.
- Rule sets, patches and previews posted back to back are applied once, as the newest (a drag in
  the rule editor posts the whole set each step), a snapshot is taken only by a command that
  changes what it holds, and a flood of presses past 1024 waiting is refused and counted.
- The input's supervision — the watchdog, ASIO reset and rate events — also runs from a Windows
  timer that a file dialog, the system menu or a message box goes on serving, where Slint's timers
  stop: a rate change met while IMPORT's dialog was open waited until it closed.

Author: Fohdeesha

src/cli/main.cpp

@@ -31,6 +31,7 @@
 #include "core/output/output_runner.hpp"
 #include "core/output/transports.hpp"
 #include "core/rt/alloc_guard.hpp"
+#include "core/rt/thread_priority.hpp"
 #include "core/tracking/beat_decoder.hpp"
 #include "core/tracking/forward_filter.hpp"
 #include "core/tracking/particle_filter.hpp"
@@ -1202,9 +1203,6 @@ int runTrackDevice(const TrackArgs& args, const takt4::model::ModelWeights& weig
             : takt4::audio::ChannelSelection::pair(args.beats.stream.pair->first,
                                                    args.beats.stream.pair->second);
     takt4::engine::BeatEngine* const engine = &tracker.engine();
-    if (args.holdBpm > 0.0) {
-        (void)engine->post(takt4::engine::Command::holdTempo(args.holdBpm));
-    }
 
     // **The declaration order from here down is the destruction order reversed, and all of
     // it is load-bearing.** Everything below runs to completion in the ordinary path; what
@@ -1232,6 +1230,11 @@ int runTrackDevice(const TrackArgs& args, const takt4::model::ModelWeights& weig
     // noticed it. `LiveTracker::start` installs it, and resets its filter, before the stream.
     tracker.setHostTimeSource(&runner.hostTimeClock());
     tracker.start(device, selection);
+    // The tempo hold once the run has started: posted before, it was applied to the run START
+    // ends (`BeatEngine::start` stops first) and let go of by the reset that begins the new one.
+    if (args.holdBpm > 0.0) {
+        (void)engine->post(takt4::engine::Command::holdTempo(args.holdBpm));
+    }
     const takt4::audio::InputStream& stream = *tracker.stream();
     FrameTracer tracer;
     if (args.traceOut) {
@@ -1505,6 +1508,9 @@ int main(int argc, char** argv) {
 #if defined(_WIN32)
     SetConsoleOutputCP(CP_UTF8);
 #endif
+    // A console behind other windows is throttled as a minimised one is — see
+    // `rt::keepFullSpeed`. `track` drives the outputs from here.
+    (void)takt4::rt::keepFullSpeed();
     std::vector<std::string_view> args(argv + 1, argv + argc);
     if (args.empty() || args[0] == "--help" || args[0] == "-h") {
         printUsage(std::cout);

src/core/CMakeLists.txt

@@ -171,6 +171,7 @@ add_library(takt4_core STATIC
   output/output_target.hpp
   output/output_runner.cpp
   output/output_runner.hpp
+  output/rtmidi_errors.hpp
   output/rule_sink.cpp
   output/rule_sink.hpp
   output/transports.cpp

src/core/control/midi_control.cpp

@@ -1,6 +1,7 @@
 #include "core/control/midi_control.hpp"
 
 #include "core/output/midi_ports.hpp"
+#include "core/output/rtmidi_errors.hpp"
 #include "core/sandbox.hpp"
 
 #include <RtMidi.h>
@@ -50,6 +51,8 @@ bool isRelease(const MidiEvent& event) noexcept {
 } // namespace
 
 struct MidiControl::Impl {
+    /// Before `in`, which reports to it and so must go first.
+    output::RtMidiErrors errors;
     RtMidiIn in;
 };
 
@@ -77,11 +80,13 @@ void MidiControl::start() {
                                  error.getMessage() + ")");
     }
 
+    impl->errors.watch(impl->in);
     unsigned int index = 0;
     std::string name;
     try {
         index = findPort(impl->in, config_.port); // output::MidiPortMissing: not here
         name = impl->in.getPortName(index);
+        impl->errors.raise();
     } catch (const RtMidiError& error) {
         throw std::runtime_error("MIDI control: " + error.getMessage());
     }
@@ -92,6 +97,7 @@ void MidiControl::start() {
     }
     try {
         impl->in.openPort(index, "takt4 control");
+        impl->errors.raise();
     } catch (const RtMidiError& error) {
         // Listed and refused: a WinMM input is one program's at a time, and a DAW that opened
         // every input it saw is the usual holder. Not "no such port" — the operator can see it.
@@ -140,6 +146,7 @@ void MidiControl::stop() noexcept {
         try {
             impl_->in.cancelCallback();
             impl_->in.closePort();
+            impl_->errors.raise();
         } catch (const RtMidiError&) {
             // Closing a port that is already gone — an unplugged controller — is not
             // something a stop path can usefully report.

src/core/engine/beat_engine.cpp

@@ -84,6 +84,13 @@ void BeatEngine::setHostTimeSource(audio::HostTimeSource* source) noexcept {
 }
 
 void BeatEngine::start() {
+    // **The presses made while stopped go first**: a ÷2, ×2, tap, pin or DOWNBEAT from a control
+    // surface between sets — the window greys its own. `stop` below takes what is queued and
+    // applies it to the run that ended, and the reset after it undoes most of a press — but not a
+    // tap, which moves the BPM window, a setting: a tap on a pad between sets moved the next
+    // set's window. The settings posted meanwhile stay, for the run about to start. See
+    // `ControlQueue::dropPresses`.
+    controls_.dropPresses();
     stop();
 
     EngineFrame frame;

src/core/engine/control.cpp

@@ -24,6 +24,14 @@ bool ControlQueue::post(const Command& command) {
         });
         pending_.erase(stale, pending_.end());
     }
+    if (pending_.size() >= kCapacity && isSetting(command.kind)) {
+        const auto press = std::find_if(pending_.begin(), pending_.end(),
+                                        [](const Command& c) { return !isSetting(c.kind); });
+        if (press != pending_.end()) {
+            pending_.erase(press);
+            ++dropped_;
+        }
+    }
     if (pending_.size() >= kCapacity) {
         ++dropped_;
         return false;
@@ -32,6 +40,11 @@ bool ControlQueue::post(const Command& command) {
     return true;
 }
 
+void ControlQueue::dropPresses() {
+    const std::lock_guard<std::mutex> lock(mutex_);
+    std::erase_if(pending_, [](const Command& c) { return !isSetting(c.kind); });
+}
+
 void ControlQueue::drain(std::vector<Command>& out) {
     out.clear();
     const std::lock_guard<std::mutex> lock(mutex_);

src/core/engine/control.hpp

@@ -73,6 +73,15 @@ struct Command {
     static Command holdTempo(double bpm) noexcept { return Command{Kind::HoldTempo, {}, bpm, false}; }
 };
 
+/// **A setting, not a press**: what the operator has set up rather than something done to the
+/// tracker at a moment — the settings (`SetTempoOptions`) and the tempo hold named directly
+/// (`HoldTempo`, which the console sets before it starts). The rest — ÷2, ×2, DOWNBEAT, a tap, a
+/// pin — act on what the tracker is hearing at the press, and mean nothing to a tracker that is
+/// stopped.
+constexpr bool isSetting(Command::Kind kind) noexcept {
+    return kind == Command::Kind::SetTempoOptions || kind == Command::Kind::HoldTempo;
+}
+
 /// The road into the inference thread: many writers, one reader, bounded, no allocation
 /// once it is warm.
 ///
@@ -96,8 +105,18 @@ class ControlQueue {
     /// Any thread but the audio one. False when the queue is full, and then `dropped()`
     /// counts it. A SetTempoOptions supersedes any already waiting rather than queueing
     /// behind it, so a slider dragged while nothing is draining cannot fill this.
+    ///
+    /// **A setting is never refused** (`isSetting`): a queue full of presses — 64 of them posted
+    /// while nothing drained, a stopped tracker and a control surface — gives up the oldest press
+    /// for it, counted as dropped. It used to refuse the setting, so the latency and BPM window
+    /// sliders moved on screen and reached nothing.
     bool post(const Command& command);
 
+    /// Drops every press waiting (`isSetting`), keeping the settings in their order. What START
+    /// does before it applies what was posted while the tracker was stopped: a ÷2, a pin or a
+    /// DOWNBEAT pressed on a control surface between sets would otherwise land on the next run.
+    void dropPresses();
+
     /// The consumer. Takes everything waiting, in the order it was posted, and leaves the
     /// queue empty. `out` is cleared first. Keep the same vector across calls, **reserved to
     /// `kCapacity` before the first**, and this allocates nothing: the queue swaps it in and

src/core/output/midi_clock.cpp

@@ -1,5 +1,7 @@
 #include "core/output/midi_clock.hpp"
 
+#include "core/output/rtmidi_errors.hpp"
+
 #include "core/output/midi_ports.hpp"
 #include "core/sandbox.hpp"
 
@@ -57,6 +59,7 @@ class RtMidiPort final : public MidiPort {
     RtMidiPort() {
         try {
             out_ = std::make_unique<RtMidiOut>();
+            errors_.watch(*out_);
         } catch (const RtMidiError& error) {
             // A machine can have no usable MIDI API at all — a headless Linux box without an
             // ALSA sequencer is the ordinary case, and CI runs on one — and RtMidi reports
@@ -81,6 +84,7 @@ class RtMidiPort final : public MidiPort {
         try {
             index = findPort(*out_, spec); // MidiPortMissing: not on this machine
             name = out_->getPortName(index);
+            errors_.raise();
         } catch (const RtMidiError& error) {
             throw std::runtime_error("MIDI output: " + error.getMessage());
         }
@@ -92,6 +96,7 @@ class RtMidiPort final : public MidiPort {
         }
         try {
             out_->openPort(index, "takt4");
+            errors_.raise();
         } catch (const RtMidiError& error) {
             // Listed, and refused: on Windows a MIDI port is one program's at a time, so this is
             // another program holding it far more often than a broken driver — and saying "no
@@ -108,6 +113,7 @@ class RtMidiPort final : public MidiPort {
         }
         try {
             out_->closePort();
+            errors_.raise();
         } catch (...) {
             // A port that is already gone cannot be closed any more gone.
         }
@@ -123,9 +129,12 @@ class RtMidiPort final : public MidiPort {
             throw std::runtime_error("MIDI output: the port is not open");
         }
         out_->sendMessage(message.data(), message.size());
+        errors_.raise();
     }
 
 private:
+    /// Before `out_`, which reports to it and so must go first.
+    RtMidiErrors errors_;
     std::unique_ptr<RtMidiOut> out_;
     /// RtMidi's reason, when it could not start at all and `out_` is empty.
     std::string unusable_;

src/core/output/midi_ports.cpp

@@ -1,5 +1,7 @@
 #include "core/output/midi_ports.hpp"
 
+#include "core/output/rtmidi_errors.hpp"
+
 #include <RtMidi.h>
 
 #include <algorithm>
@@ -27,12 +29,15 @@ template <typename Midi>
 std::vector<std::string> listPorts() {
     std::vector<std::string> ports;
     try {
+        RtMidiErrors errors;
         Midi midi;
+        errors.watch(midi);
         const unsigned int count = midi.getPortCount();
         ports.reserve(count);
         for (unsigned int i = 0; i < count; ++i) {
             ports.push_back(midi.getPortName(i));
         }
+        errors.raise();
     } catch (const RtMidiError&) {
         // No usable MIDI API on this machine; see the header.
     }