extented callbacks now optional to save weight

examples/EthernetShield_Callbacks/EthernetShield_Callbacks.ino

@@ -0,0 +1,82 @@
+#include <Ethernet.h>
+
+#define DISCARD_SESSION_NAME
+#define NO_LATENCY_CALCULATION
+#define NO_EXT_CALLBACKS
+#define SerialMon Serial
+#define APPLEMIDI_DEBUG SerialMon
+#include <AppleMIDI.h>
+
+// Enter a MAC address for your controller below.
+// Newer Ethernet shields have a MAC address printed on a sticker on the shield
+byte mac[] = {
+  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED
+};
+
+unsigned long t1 = millis();
+bool isConnected = false;
+
+APPLEMIDI_CREATE_DEFAULTSESSION_INSTANCE();
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+void setup()
+{
+  DBG_SETUP(115200);
+  DBG("Booting");
+
+  if (Ethernet.begin(mac) == 0) {
+    DBG(F("Failed DHCP, check network cable & reboot"));
+    for (;;);
+  }
+
+  DBG(F("OK, now make sure you an rtpMIDI session that is Enabled"));
+  DBG(F("Add device named Arduino with Host"), Ethernet.localIP(), "Port", AppleMIDI.getPort(), "(Name", AppleMIDI.getName(), ")");
+  DBG(F("Select and then press the Connect button"));
+  DBG(F("Then open a MIDI listener and monitor incoming notes"));
+
+  MIDI.begin();
+
+  // Stay informed on connection status
+  AppleMIDI.setHandleConnected([](const APPLEMIDI_NAMESPACE::ssrc_t & ssrc, const char* name) {
+    isConnected = true;
+    DBG(F("Connected to session"), name);
+  });
+  AppleMIDI.setHandleDisconnected([](const APPLEMIDI_NAMESPACE::ssrc_t & ssrc) {
+    isConnected = false;
+    DBG(F("Disconnected"));
+  });
+
+  MIDI.setHandleNoteOn([](byte channel, byte note, byte velocity) {
+    DBG(F("NoteOn"), note);
+  });
+  MIDI.setHandleNoteOff([](byte channel, byte note, byte velocity) {
+    DBG(F("NoteOff"), note);
+  });
+
+  DBG(F("Sending MIDI messages every second"));
+}
+
+// -----------------------------------------------------------------------------
+//
+// -----------------------------------------------------------------------------
+void loop()
+{
+  // Listen to incoming notes
+  MIDI.read();
+
+  // send a note every second
+  // (dont cáll delay(1000) as it will stall the pipeline)
+  if (isConnected && (millis() - t1) > 1000)
+  {
+    t1 = millis();
+
+    byte note = random(1, 127);
+    byte velocity = 55;
+    byte channel = 1;
+
+    MIDI.sendNoteOn(note, velocity, channel);
+//    MIDI.sendNoteOff(note, velocity, channel);
+  }
+}

src/AppleMIDI.h

@@ -55,12 +55,14 @@ class AppleMIDISession
 
 	void setHandleConnected(void (*fptr)(const ssrc_t&, const char*)) { _connectedCallback = fptr; }
 	void setHandleDisconnected(void (*fptr)(const ssrc_t&)) { _disconnectedCallback = fptr; }
-    void setHandleException(void (*fptr)(const ssrc_t&, const Exception&, const int32_t value)) { _exceptionCallback = fptr; }
+#ifdef USE_EXT_CALLBACKS
+   void setHandleException(void (*fptr)(const ssrc_t&, const Exception&, const int32_t value)) { _exceptionCallback = fptr; }
     void setHandleReceivedRtp(void (*fptr)(const Rtp_t&, const int32_t&)) { _receivedRtpCallback = fptr; }
     void setHandleStartReceivedMidi(void (*fptr)(const ssrc_t&)) { _startReceivedMidiByteCallback = fptr; }
     void setHandleReceivedMidi(void (*fptr)(const ssrc_t&, byte)) { _receivedMidiByteCallback = fptr; }
     void setHandleEndReceivedMidi(void (*fptr)(const ssrc_t&)) { _endReceivedMidiByteCallback = fptr; }
     void setHandleSendRtp(void (*fptr)(const Rtp_t&)) { _sendRtpCallback = fptr; }
+#endif
 
     const char*    getName() { return this->localName; };
     const uint16_t getPort() { return this->port; };
@@ -74,6 +76,7 @@ class AppleMIDISession
     void sendEndSession();
 
 public:
+    // Override default thruActivated
     static const bool thruActivated = false;
 
 	void begin()
@@ -91,7 +94,6 @@ class AppleMIDISession
 		// this is our SSRC
         //
         // NOTE: Arduino random only goes to INT32_MAX (not UINT32_MAX)
-
 		this->ssrc = random(1, INT32_MAX) * 2;
 
 		controlPort.begin(port);
@@ -151,8 +153,10 @@ class AppleMIDISession
             }
 			else
 			{
+#ifdef USE_EXT_CALLBACKS
                 if (nullptr != _exceptionCallback)
                     _exceptionCallback(ssrc, BufferFullException, 0);
+#endif
 			}
 		}
 
@@ -219,14 +223,15 @@ class AppleMIDISession
 	rtpMIDIParser<UdpClass, Settings, Platform> _rtpMIDIParser;
 
     connectedCallback _connectedCallback = nullptr;
+    disconnectedCallback _disconnectedCallback = nullptr;
+#ifdef USE_EXT_CALLBACKS
     startReceivedMidiByteCallback _startReceivedMidiByteCallback = nullptr;
     receivedMidiByteCallback _receivedMidiByteCallback = nullptr;
     endReceivedMidiByteCallback _endReceivedMidiByteCallback = nullptr;
     receivedRtpCallback _receivedRtpCallback = nullptr;
-    disconnectedCallback _disconnectedCallback = nullptr;
-    exceptionCallback _exceptionCallback = nullptr;
     sendRtpCallback _sendRtpCallback = nullptr;
-
+    exceptionCallback _exceptionCallback = nullptr;
+#endif
 	// buffer for incoming and outgoing MIDI messages
 	MidiBuffer_t inMidiBuffer;
 	MidiBuffer_t outMidiBuffer;
@@ -237,7 +242,7 @@ class AppleMIDISession
     char localName[DefaultSettings::MaxSessionNameLen + 1];
 	uint16_t port = DEFAULT_CONTROL_PORT;
     Deque<Participant<Settings>, Settings::MaxNumberOfParticipants> participants;
-    int32_t latencyAdjustment = 0;
+//    int32_t latencyAdjustment = 0; // not used
 
 private:
     void readControlPackets();

src/AppleMIDI.hpp

@@ -30,9 +30,10 @@ void AppleMIDISession<UdpClass, Settings, Platform>::parseControlPackets()
         auto retVal = _appleMIDIParser.parse(controlBuffer, amPortType::Control);
         if (retVal == parserReturn::UnexpectedData)
         {
+#ifdef USE_EXT_CALLBACKS
             if (nullptr != _exceptionCallback)
                 _exceptionCallback(ssrc, ParseException, 0);
-
+#endif            
             controlBuffer.pop_front();
         }
     }
@@ -81,9 +82,10 @@ void AppleMIDISession<UdpClass, Settings, Platform>::parseDataPackets()
         ||  retVal2 == parserReturn::NotSureGiveMeMoreData)
             break; // one or the other buffer does not have enough data
 
+#ifdef USE_EXT_CALLBACKS
         if (nullptr != _exceptionCallback)
             _exceptionCallback(ssrc, UnexpectedParseException, 0);
-
+#endif
          dataBuffer.pop_front();
     }
 }
@@ -114,9 +116,10 @@ void AppleMIDISession<UdpClass, Settings, Platform>::ReceivedControlInvitation(A
     {
         writeInvitation(controlPort, controlPort.remoteIP(), controlPort.remotePort(), invitation, amInvitationRejected);
 
+#ifdef USE_EXT_CALLBACKS
         if (nullptr != _exceptionCallback)
             _exceptionCallback(ssrc, TooManyParticipantsException, 0);
-
+#endif
         return;
     }
 
@@ -143,9 +146,10 @@ void AppleMIDISession<UdpClass, Settings, Platform>::ReceivedDataInvitation(Appl
     {
         writeInvitation(dataPort, dataPort.remoteIP(), dataPort.remotePort(), invitation, amInvitationRejected);
 
+#ifdef USE_EXT_CALLBACKS
         if (nullptr != _exceptionCallback)
             _exceptionCallback(ssrc, ParticipantNotFoundException, invitation.ssrc);
-        
+#endif  
         return;
     }
 
@@ -259,6 +263,11 @@ void AppleMIDISession<UdpClass, Settings, Platform>::ReceivedSynchronization(App
     auto participant = getParticipantBySSRC(synchronization.ssrc);
     if (nullptr == participant)
     {
+#ifdef USE_EXT_CALLBACKS
+        if (nullptr != _exceptionCallback)
+            _exceptionCallback(ssrc, ParticipantNotFoundException, synchronization.ssrc);
+#endif  
+
         return;
     }
 
@@ -313,19 +322,6 @@ void AppleMIDISession<UdpClass, Settings, Platform>::ReceivedSynchronization(App
 #ifdef LATENCY_CALCULATION
         // each party can estimate the offset between the two clocks using the following formula
         participant->offsetEstimate = (uint32_t)(((synchronization.timestamps[2] + synchronization.timestamps[0]) / 2) - synchronization.timestamps[1]);
-/*
-        uint64_t remoteAverage   = ((synchronization.timestamps[2] + synchronization.timestamps[0]) / 2);
-        uint64_t localAverage    =   synchronization.timestamps[1];
-
-        static uint64_t oldRemoteAverage = 0;
-        static uint64_t oldLocalAverage  = 0;
-
-        uint64_t r = (remoteAverage - oldRemoteAverage);
-        uint64_t l = (localAverage  - oldLocalAverage);
-
-        oldRemoteAverage = remoteAverage;
-        oldLocalAverage  = localAverage;
-*/
 #endif
         break;
     }
@@ -348,18 +344,20 @@ void AppleMIDISession<UdpClass, Settings, Platform>::ReceivedReceiverFeedback(Ap
     // Here is where you would correct if packets are dropped (send them again)
 
     auto participant = getParticipantBySSRC(receiverFeedback.ssrc);
-    if (nullptr != participant) {
-        if (participant->sendSequenceNr != receiverFeedback.sequenceNr)
-        {
-            Serial.print("ERRORRORORORORORORRROROROROROROR");
-
-            if (nullptr != _exceptionCallback)
-                _exceptionCallback(ssrc, SendPacketsDropped, participant->sendSequenceNr - receiverFeedback.sequenceNr);
+    if (nullptr == participant) {
+#ifdef USE_EXT_CALLBACKS
+        if (nullptr != _exceptionCallback)
+            _exceptionCallback(ssrc, ParticipantNotFoundException, receiverFeedback.ssrc);
+#endif  
+        return;
+    }
 
-            Serial.print(participant->sendSequenceNr);
-            Serial.print(" ");
-            Serial.println(receiverFeedback.sequenceNr);
-        }
+    if (participant->sendSequenceNr != receiverFeedback.sequenceNr)
+    {
+#ifdef USE_EXT_CALLBACKS
+        if (nullptr != _exceptionCallback)
+            _exceptionCallback(ssrc, SendPacketsDropped, participant->sendSequenceNr - receiverFeedback.sequenceNr);
+#endif
     }
 }
 
@@ -516,16 +514,19 @@ void AppleMIDISession<UdpClass, Settings, Platform>::writeRtpMidiBuffer(Particip
     // have an option to not transmit messages with future timestamps, to accommodate hardware not
     // prepared to defer rendering the messages until the proper time.)
     //
-    rtp.timestamp = (Settings::TimestampRtpPackets) ? htonl(rtpMidiClock.Now()) : 0;
+    rtp.timestamp = (Settings::TimestampRtpPackets) ? rtpMidiClock.Now() : 0;
 
     // increment the sequenceNr
     participant->sendSequenceNr++;
 
     rtp.sequenceNr = participant->sendSequenceNr;
 
+#ifdef USE_EXT_CALLBACKS
     if (_sendRtpCallback)
         _sendRtpCallback(rtp);
+#endif
 
+    rtp.timestamp  = htonl(rtp.timestamp);
     rtp.ssrc       = htonl(rtp.ssrc);
     rtp.sequenceNr = htons(rtp.sequenceNr);
 
@@ -606,9 +607,10 @@ void AppleMIDISession<UdpClass, Settings, Platform>::manageSynchronizationListen
     // otherwise the responder may assume that the initiator has died and terminate the session.
     if (now - participant->lastSyncExchangeTime > Settings::CK_MaxTimeOut)
     {
+#ifdef USE_EXT_CALLBACKS
         if (nullptr != _exceptionCallback)
             _exceptionCallback(ssrc, ListenerTimeOutException, 0);
-
+#endif
         sendEndSession(participant);
 
         participants.erase(i);
@@ -672,9 +674,10 @@ void AppleMIDISession<UdpClass, Settings, Platform>::manageSynchronizationInitia
     {
         if (participant->synchronizationCount > DefaultSettings::MaxSynchronizationCK0Attempts)
         {
+#ifdef USE_EXT_CALLBACKS
             if (nullptr != _exceptionCallback)
                 _exceptionCallback(ssrc, MaxAttemptsException, 0);
-
+#endif
             // After too many attempts, stop.
             sendEndSession(participant);
 
@@ -731,9 +734,10 @@ void AppleMIDISession<UdpClass, Settings, Platform>::manageSessionInvites()
         {
             if (participant->connectionAttempts >= DefaultSettings::MaxSessionInvitesAttempts)
             {
+#ifdef USE_EXT_CALLBACKS
                 if (nullptr != _exceptionCallback)
                     _exceptionCallback(ssrc, NoResponseFromConnectionRequestException, 0);
-
+#endif
                 // After too many attempts, stop.
                 sendEndSession(participant);
 
@@ -869,19 +873,18 @@ void AppleMIDISession<UdpClass, Settings, Platform>::ReceivedRtp(const Rtp_t& rt
 
         if (participant->receiveSequenceNr + 1 != rtp.sequenceNr) {
 
+#ifdef USE_EXT_CALLBACKS
             if (nullptr != _exceptionCallback)
                 _exceptionCallback(ssrc, ReceivedPacketsDropped, participant->receiveSequenceNr + 1 - rtp.sequenceNr);
-
-            Serial.print("___ERROR____");
-            Serial.print(participant->receiveSequenceNr);
-            Serial.print(" ");
-            Serial.println(rtp.sequenceNr);
+#endif
         }
 
         participant->receiveSequenceNr = rtp.sequenceNr;
 
+#ifdef USE_EXT_CALLBACKS
         if (nullptr != _receivedRtpCallback)
             _receivedRtpCallback(rtp, latency);
+#endif
     }
     else
     {
@@ -892,24 +895,30 @@ void AppleMIDISession<UdpClass, Settings, Platform>::ReceivedRtp(const Rtp_t& rt
 template <class UdpClass, class Settings, class Platform>
 void AppleMIDISession<UdpClass, Settings, Platform>::StartReceivedMidi()
 {
+#ifdef USE_EXT_CALLBACKS
    if (nullptr != _startReceivedMidiByteCallback)
         _startReceivedMidiByteCallback(0);
+#endif
 }
 
 template <class UdpClass, class Settings, class Platform>
 void AppleMIDISession<UdpClass, Settings, Platform>::ReceivedMidi(byte value)
 {
+#ifdef USE_EXT_CALLBACKS
     if (nullptr != _receivedMidiByteCallback)
         _receivedMidiByteCallback(0, value);
+#endif
 
     inMidiBuffer.push_back(value);
 }
 
 template <class UdpClass, class Settings, class Platform>
 void AppleMIDISession<UdpClass, Settings, Platform>::EndReceivedMidi()
 {
+#ifdef USE_EXT_CALLBACKS
     if (nullptr != _endReceivedMidiByteCallback)
         _endReceivedMidiByteCallback(0);
+#endif
 }
 
 END_APPLEMIDI_NAMESPACE