Line data Source code
1 : #pragma once
2 :
3 : #include "MIDI_Pipes.hpp"
4 : #include "MIDI_Sender.hpp"
5 : #include "MIDI_Staller.hpp"
6 : #include <AH/Containers/Updatable.hpp>
7 : #include <Def/Def.hpp>
8 : #include <Def/MIDIAddress.hpp>
9 : #include <MIDI_Parsers/MIDI_Parser.hpp>
10 :
11 : BEGIN_CS_NAMESPACE
12 :
13 : constexpr auto MIDI_BAUD = 31250;
14 :
15 : class MIDI_Callbacks;
16 :
17 : /**
18 : * @brief An abstract class for MIDI interfaces.
19 : */
20 : class MIDI_Interface : public TrueMIDI_SinkSource,
21 : public MIDI_Sender<MIDI_Interface>,
22 : public AH::Updatable<MIDI_Interface>,
23 : protected MIDIStaller {
24 : protected:
25 135 : MIDI_Interface() = default;
26 : MIDI_Interface(MIDI_Interface &&) = default;
27 :
28 : public:
29 : /// Destructor.
30 : virtual ~MIDI_Interface();
31 :
32 : /// Initialize the MIDI Interface.
33 3 : void begin() override {}
34 : /// Read the MIDI interface and call the callback if a message was received.
35 : void update() override = 0;
36 :
37 : /// @name Default MIDI Interfaces
38 : /// @{
39 :
40 : /// Set this MIDI interface as the default interface.
41 : void setAsDefault();
42 : /// Return the default MIDI interface. If the default MIDI interface was
43 : /// configured explicitly using @ref setAsDefault(), that interface is
44 : /// returned. If it wasn't set, or if that MIDI interface no longer exists,
45 : /// this function returns the newest MIDI interface, the one that was
46 : /// constructed most recently. If no MIDI interfaces exist, `nullptr` is
47 : /// returned.
48 : static MIDI_Interface *getDefault();
49 :
50 : /// @}
51 :
52 : /// @name MIDI Input Callbacks
53 : /// @{
54 :
55 : /// Set the callbacks that will be called when a MIDI message is received.
56 : /// @param cb
57 : /// A pointer to the callback object.
58 15 : void setCallbacks(MIDI_Callbacks *cb) { this->callbacks = cb; }
59 : /// Set the callbacks that will be called when a MIDI message is received.
60 : /// @param cb
61 : /// A reference to the callback object.
62 3 : void setCallbacks(MIDI_Callbacks &cb) { setCallbacks(&cb); }
63 :
64 : /// @}
65 :
66 : protected:
67 : friend class MIDI_Sender<MIDI_Interface>;
68 : /// Low-level function for sending a MIDI channel voice message.
69 : virtual void sendChannelMessageImpl(ChannelMessage) = 0;
70 : /// Low-level function for sending a MIDI system common message.
71 : virtual void sendSysCommonImpl(SysCommonMessage) = 0;
72 : /// Low-level function for sending a system exclusive MIDI message.
73 : virtual void sendSysExImpl(SysExMessage) = 0;
74 : /// Low-level function for sending a MIDI real-time message.
75 : virtual void sendRealTimeImpl(RealTimeMessage) = 0;
76 : /// Low-level function for sending any buffered outgoing MIDI messages.
77 : virtual void sendNowImpl() = 0;
78 :
79 : public:
80 : #if DISABLE_PIPES
81 : virtual MIDIReadEvent read() = 0;
82 : virtual ChannelMessage getChannelMessage() const = 0;
83 : virtual SysCommonMessage getSysCommonMessage() const = 0;
84 : virtual RealTimeMessage getRealTimeMessage() const = 0;
85 : virtual SysExMessage getSysExMessage() const = 0;
86 : #endif
87 :
88 : protected:
89 : #if !DISABLE_PIPES
90 : /// Accept an incoming MIDI Channel message from the source pipe.
91 132 : void sinkMIDIfromPipe(ChannelMessage msg) override { send(msg); }
92 : /// Accept an incoming MIDI System Exclusive message from the source pipe.
93 8 : void sinkMIDIfromPipe(SysExMessage msg) override { send(msg); }
94 : /// Accept an incoming MIDI System Common message from the source pipe.
95 0 : void sinkMIDIfromPipe(SysCommonMessage msg) override { send(msg); }
96 : /// Accept an incoming MIDI Real-Time message from the source pipe.
97 2 : void sinkMIDIfromPipe(RealTimeMessage msg) override { send(msg); }
98 : #endif
99 :
100 : protected:
101 : /// Call the channel message callback and send the message to the sink pipe.
102 : void onChannelMessage(ChannelMessage message);
103 : /// Call the SysEx message callback and send the message to the sink pipe.
104 : void onSysExMessage(SysExMessage message);
105 : /// Call the System Common message callback and send the message to the sink
106 : /// pipe.
107 : void onSysCommonMessage(SysCommonMessage message);
108 : /// Call the real-time message callback and send the message to the sink
109 : /// pipe.
110 : void onRealTimeMessage(RealTimeMessage message);
111 :
112 : public:
113 : /// Read, parse and dispatch incoming MIDI messages on the given interface.
114 : template <class MIDIInterface_t>
115 : static void updateIncoming(MIDIInterface_t *iface);
116 : /// Dispatch the given type of MIDI message from the given interface.
117 : template <class MIDIInterface_t>
118 : static void dispatchIncoming(MIDIInterface_t *iface, MIDIReadEvent event);
119 : #if !DISABLE_PIPES
120 : /// Un-stall the given MIDI interface. Assumes the interface has been
121 : /// stalled because of a chunked SysEx messages. Waits until that message
122 : /// is finished.
123 : template <class MIDIInterface_t>
124 : static void handleStall(MIDIInterface_t *self);
125 : using MIDIStaller::handleStall;
126 : #endif
127 :
128 : private:
129 : MIDI_Callbacks *callbacks = nullptr;
130 :
131 : private:
132 : static MIDI_Interface *DefaultMIDI_Interface;
133 : };
134 :
135 : template <class MIDIInterface_t>
136 23 : void MIDI_Interface::updateIncoming(MIDIInterface_t *self) {
137 : #if DISABLE_PIPES
138 : MIDIReadEvent event = self->read();
139 : while (event != MIDIReadEvent::NO_MESSAGE) {
140 : dispatchIncoming(self, event);
141 : event = self->read();
142 : }
143 : #else
144 23 : MIDIReadEvent event = self->read();
145 23 : if (event == MIDIReadEvent::NO_MESSAGE)
146 2 : return;
147 21 : if (self->getStaller() == self)
148 0 : self->unstall(self);
149 21 : int16_t size_rem = 512 * 3 / 4; // Don't keep on reading for too long
150 21 : bool chunked = false; // Whether there's an unterminated SysEx chunk
151 59 : while (event != MIDIReadEvent::NO_MESSAGE) {
152 38 : dispatchIncoming(self, event);
153 38 : if (event == MIDIReadEvent::SYSEX_CHUNK) {
154 1 : size_rem -= self->getSysExMessage().length;
155 1 : chunked = true;
156 37 : } else if (event == MIDIReadEvent::SYSEX_MESSAGE) {
157 8 : size_rem -= self->getSysExMessage().length;
158 8 : chunked = false;
159 : } else {
160 29 : size_rem -= 3;
161 : }
162 38 : if (size_rem < 0)
163 0 : break;
164 38 : event = self->read();
165 : }
166 21 : if (chunked)
167 1 : self->stall(self);
168 : #endif
169 : // TODO: add logic to detect MIDI messages such as (N)RPN that span over
170 : // multiple channel voice messages and that shouldn't be interrupted.
171 : // For short messages such as (N)RPN, I suggest waiting with a timeout.
172 : }
173 :
174 : template <class MIDIInterface_t>
175 40 : void MIDI_Interface::dispatchIncoming(MIDIInterface_t *self,
176 : MIDIReadEvent event) {
177 40 : switch (event) {
178 25 : case MIDIReadEvent::CHANNEL_MESSAGE:
179 25 : self->onChannelMessage(self->getChannelMessage());
180 25 : break;
181 11 : case MIDIReadEvent::SYSEX_CHUNK: // fallthrough
182 : case MIDIReadEvent::SYSEX_MESSAGE:
183 11 : self->onSysExMessage(self->getSysExMessage());
184 11 : break;
185 0 : case MIDIReadEvent::SYSCOMMON_MESSAGE:
186 0 : self->onSysCommonMessage(self->getSysCommonMessage());
187 0 : break;
188 4 : case MIDIReadEvent::REALTIME_MESSAGE:
189 4 : self->onRealTimeMessage(self->getRealTimeMessage());
190 4 : break;
191 : case MIDIReadEvent::NO_MESSAGE: break; // LCOV_EXCL_LINE
192 : default: break; // LCOV_EXCL_LINE
193 : }
194 40 : }
195 :
196 : #if !DISABLE_PIPES
197 : template <class MIDIInterface_t>
198 1 : void MIDI_Interface::handleStall(MIDIInterface_t *self) {
199 1 : const char *staller_name = self->getStallerName();
200 : DEBUGFN(F("Handling stall. Cause: ") << staller_name);
201 1 : self->unstall(self);
202 :
203 1 : unsigned long startTime = millis();
204 2 : while (millis() - startTime < SYSEX_CHUNK_TIMEOUT) {
205 2 : MIDIReadEvent event = self->read();
206 2 : dispatchIncoming(self, event);
207 2 : if (event == MIDIReadEvent::SYSEX_CHUNK)
208 1 : startTime = millis(); // reset timeout
209 1 : else if (event == MIDIReadEvent::SYSEX_MESSAGE)
210 1 : return;
211 : }
212 : DEBUGFN(F("Warning: Unable to un-stall pipes. Cause: ") << staller_name);
213 : static_cast<void>(staller_name);
214 : }
215 : #endif
216 :
217 : END_CS_NAMESPACE
|
