Line data    Source code

       1             : #include <Settings/SettingsWrapper.hpp>
       2             : #if !DISABLE_PIPES
       3             : 
       4             : #include "MIDI_Pipes.hpp"
       5             : #include "MIDI_Staller.hpp"
       6             : #include <AH/Error/Error.hpp>
       7             : #include <AH/STL/utility>
       8             : 
       9             : #if defined(ESP32) || !defined(ARDUINO)
      10             : #include <mutex>
      11             : #endif
      12             : 
      13             : BEGIN_CS_NAMESPACE
      14             : 
      15             : // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: //
      16             : 
      17         401 : void MIDI_Sink::connectSourcePipe(MIDI_Pipe *source) {
      18         401 :     if (this->sourcePipe == nullptr) {
      19         306 :         source->connectSink(this);
      20         305 :         this->sourcePipe = source;
      21             :     } else {
      22          95 :         this->sourcePipe->connectSourcePipe(source);
      23             :     }
      24         400 : }
      25             : 
      26        2319 : void MIDI_Sink::disconnectSourcePipes() {
      27        2319 :     if (sourcePipe != nullptr) {
      28          68 :         sourcePipe->disconnectSourcePipes();
      29          68 :         sourcePipe->disconnect();
      30          68 :         sourcePipe = nullptr;
      31             :     }
      32        2319 : }
      33             : 
      34         305 : void MIDI_Sink::disconnectSourcePipesShallow() {
      35         305 :     if (sourcePipe != nullptr) {
      36         305 :         sourcePipe->disconnectSink();
      37         305 :         sourcePipe = nullptr;
      38             :     }
      39         305 : }
      40             : 
      41          13 : bool MIDI_Sink::disconnect(TrueMIDI_Source &source) {
      42          13 :     if (!hasSourcePipe())
      43           3 :         return false;
      44          10 :     return sourcePipe->disconnect(source);
      45             : }
      46             : 
      47        2250 : MIDI_Sink::~MIDI_Sink() { disconnectSourcePipes(); }
      48             : 
      49           5 : MIDI_Sink::MIDI_Sink(MIDI_Sink &&other)
      50           5 :     : sourcePipe(std::exchange(other.sourcePipe, nullptr)) {
      51           5 :     if (this->hasSourcePipe()) {
      52           5 :         this->sourcePipe->disconnectSink();
      53           5 :         this->sourcePipe->connectSink(this);
      54             :     }
      55           5 : }
      56             : 
      57           3 : void MIDI_Sink::swap(MIDI_Sink &a, MIDI_Sink &b) {
      58           3 :     std::swap(a.sourcePipe, b.sourcePipe);
      59           3 :     if (a.hasSourcePipe()) {
      60           3 :         a.sourcePipe->disconnectSink();
      61           3 :         a.sourcePipe->connectSink(&a);
      62             :     }
      63           3 :     if (b.hasSourcePipe()) {
      64           1 :         b.sourcePipe->disconnectSink();
      65           1 :         b.sourcePipe->connectSink(&b);
      66             :     }
      67           3 : }
      68             : 
      69           2 : MIDI_Sink &MIDI_Sink::operator=(MIDI_Sink &&other) {
      70           2 :     swap(*this, other);
      71           2 :     return *this;
      72             : }
      73             : 
      74             : // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: //
      75             : 
      76         364 : void MIDI_Source::connectSinkPipe(MIDI_Pipe *sink) {
      77         364 :     if (this->sinkPipe == nullptr) {
      78         292 :         sink->connectSource(this);
      79         291 :         this->sinkPipe = sink;
      80             :     } else {
      81          72 :         this->sinkPipe->connectSinkPipe(sink);
      82             :     }
      83         363 : }
      84             : 
      85        2433 : void MIDI_Source::disconnectSinkPipes() {
      86        2433 :     if (sinkPipe != nullptr) {
      87         165 :         sinkPipe->disconnectSinkPipes();
      88         165 :         sinkPipe->disconnect();
      89         165 :         sinkPipe = nullptr;
      90             :     }
      91        2433 : }
      92             : 
      93         291 : void MIDI_Source::disconnectSinkPipesShallow() {
      94         291 :     if (sinkPipe != nullptr) {
      95         291 :         sinkPipe->disconnectSource();
      96         291 :         sinkPipe = nullptr;
      97             :     }
      98         291 : }
      99             : 
     100          13 : bool MIDI_Source::disconnect(TrueMIDI_Sink &sink) {
     101          13 :     if (!hasSinkPipe())
     102           3 :         return false;
     103          10 :     return sinkPipe->disconnect(sink);
     104             : }
     105             : 
     106           5 : MIDI_Source::MIDI_Source(MIDI_Source &&other)
     107           5 :     : sinkPipe(std::exchange(other.sinkPipe, nullptr)) {
     108           5 :     if (this->hasSinkPipe()) {
     109           5 :         this->sinkPipe->disconnectSource();
     110           5 :         this->sinkPipe->connectSource(this);
     111             :     }
     112           5 : }
     113             : 
     114           3 : void MIDI_Source::swap(MIDI_Source &a, MIDI_Source &b) {
     115           3 :     std::swap(a.sinkPipe, b.sinkPipe);
     116           3 :     if (a.hasSinkPipe()) {
     117           3 :         a.sinkPipe->disconnectSource();
     118           3 :         a.sinkPipe->connectSource(&a);
     119             :     }
     120           3 :     if (b.hasSinkPipe()) {
     121           1 :         b.sinkPipe->disconnectSource();
     122           1 :         b.sinkPipe->connectSource(&b);
     123             :     }
     124           3 : }
     125             : 
     126           2 : MIDI_Source &MIDI_Source::operator=(MIDI_Source &&other) {
     127           2 :     swap(*this, other);
     128           2 :     return *this;
     129             : }
     130             : 
     131        2266 : MIDI_Source::~MIDI_Source() { disconnectSinkPipes(); }
     132             : 
     133         158 : void MIDI_Source::sourceMIDItoPipe(ChannelMessage msg) {
     134         158 :     if (sinkPipe != nullptr) {
     135         136 :         handleStallers();
     136         136 :         sinkPipe->acceptMIDIfromSource(msg);
     137             :     }
     138         158 : }
     139          15 : void MIDI_Source::sourceMIDItoPipe(SysExMessage msg) {
     140          15 :     if (sinkPipe != nullptr) {
     141          10 :         handleStallers();
     142          10 :         sinkPipe->acceptMIDIfromSource(msg);
     143             :     }
     144          15 : }
     145           0 : void MIDI_Source::sourceMIDItoPipe(SysCommonMessage msg) {
     146           0 :     if (sinkPipe != nullptr) {
     147           0 :         handleStallers();
     148           0 :         sinkPipe->acceptMIDIfromSource(msg);
     149             :     }
     150           0 : }
     151          19 : void MIDI_Source::sourceMIDItoPipe(RealTimeMessage msg) {
     152          19 :     if (sinkPipe != nullptr) {
     153             :         // Always send write to pipe, don't check if it's stalled or not
     154          15 :         sinkPipe->acceptMIDIfromSource(msg);
     155             :     }
     156          19 : }
     157             : 
     158          36 : void MIDI_Source::stall(MIDIStaller *cause) {
     159          36 :     if (hasSinkPipe())
     160          36 :         sinkPipe->stallDownstream(cause, this);
     161             :     DEBUGFN(F("Stalled MIDI source. Cause: ") << getStallerName());
     162          35 : }
     163             : 
     164          22 : void MIDI_Source::unstall(MIDIStaller *cause) {
     165             :     DEBUGFN(F("Un-stalling MIDI source. Cause: ") << getStallerName());
     166          22 :     if (hasSinkPipe())
     167          22 :         sinkPipe->unstallDownstream(cause, this);
     168          21 : }
     169             : 
     170          40 : bool MIDI_Source::isStalled() const {
     171          40 :     if (hasSinkPipe())
     172          36 :         return sinkPipe->isStalled();
     173           4 :     return false;
     174             : }
     175             : 
     176          30 : MIDIStaller *MIDI_Source::getStaller() const {
     177          30 :     if (hasSinkPipe())
     178          15 :         return sinkPipe->getStaller();
     179          15 :     return nullptr;
     180             : }
     181             : 
     182           5 : const char *MIDI_Source::getStallerName() const {
     183           5 :     return MIDIStaller::getNameNull(getStaller());
     184             : }
     185             : 
     186         151 : void MIDI_Source::handleStallers() const {
     187         151 :     if (hasSinkPipe())
     188         151 :         sinkPipe->handleStallers();
     189         150 : }
     190             : 
     191             : // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: //
     192             : 
     193         315 : void MIDI_Pipe::connectSink(MIDI_Sink *sink) {
     194         315 :     if (this->sink != nullptr) {
     195           1 :         FATAL_ERROR(F("This pipe is already connected to a sink"), 0x9145);
     196             :         return; // LCOV_EXCL_LINE
     197             :     }
     198         314 :     this->sink = sink;
     199             : }
     200             : 
     201         314 : void MIDI_Pipe::disconnectSink() { this->sink = nullptr; }
     202             : 
     203         301 : void MIDI_Pipe::connectSource(MIDI_Source *source) {
     204         301 :     if (this->source != nullptr) {
     205           1 :         FATAL_ERROR(F("This pipe is already connected to a source"), 0x9146);
     206             :         return; // LCOV_EXCL_LINE
     207             :     }
     208         300 :     this->source = source;
     209             : }
     210             : 
     211         300 : void MIDI_Pipe::disconnectSource() { this->source = nullptr; }
     212             : 
     213        1657 : void MIDI_Pipe::disconnect() {
     214        1657 :     if (hasSink() && hasThroughIn()) {
     215          26 :         auto oldSink = sink;
     216          26 :         auto oldThroughIn = getThroughIn();
     217          26 :         sink->disconnectSourcePipesShallow();
     218          26 :         this->disconnectSourcePipesShallow(); // disconnect throughIn
     219          26 :         oldSink->connectSourcePipe(oldThroughIn);
     220             :     }
     221        1657 :     if (hasSource() && hasThroughOut()) {
     222          14 :         auto oldSource = source;
     223          14 :         auto oldThroughOut = getThroughOut();
     224          14 :         source->disconnectSinkPipesShallow();
     225          14 :         this->disconnectSinkPipesShallow(); // disconnect throughOut
     226          14 :         oldSource->connectSinkPipe(oldThroughOut);
     227             :     }
     228        1657 :     if (hasSink())
     229         253 :         sink->disconnectSourcePipesShallow();
     230             : 
     231        1657 :     if (hasSource())
     232         263 :         source->disconnectSinkPipesShallow();
     233             : 
     234        1657 :     if (hasThroughIn() || hasThroughOut())
     235             :         FATAL_ERROR(F("Invalid state"), 0x9147); // LCOV_EXCL_LINE
     236        1657 : }
     237             : 
     238        1406 : MIDI_Pipe::~MIDI_Pipe() { disconnect(); }
     239             : 
     240          74 : void MIDI_Pipe::stallDownstream(MIDIStaller *cause, MIDI_Source *stallsrc) {
     241          74 :     if (!sinkIsUnstalledOrStalledBy(cause)) {
     242           1 :         FATAL_ERROR(F("Cannot stall pipe from ")
     243             :                         << MIDIStaller::getNameNull(cause)
     244             :                         << F(" because pipe is already stalled by ")
     245             :                         << MIDIStaller::getNameNull(sink_staller),
     246             :                     0x6665);
     247             :     } // LCOV_EXCL_LINE
     248          73 :     sink_staller = cause;
     249          73 :     if (hasThroughOut() && stallsrc == source)
     250           1 :         getThroughOut()->stallDownstream(cause, this);
     251          73 :     if (hasSink())
     252          73 :         sink->stallDownstream(cause, this);
     253          73 :     if (hasSource() && source != stallsrc) {
     254             :         // If our through output is stalled, that means our upstream is stalled
     255             :         // as well by this staller. Unstall it first, and replace it by the new
     256             :         // staller
     257          37 :         if (through_staller != nullptr)
     258           3 :             source->unstallUpstream(through_staller, this);
     259          37 :         source->stallUpstream(cause, this);
     260             :     }
     261          73 :     if (hasThroughIn() && getThroughIn() != stallsrc)
     262           8 :         getThroughIn()->stallUpstream(cause, this);
     263          73 : }
     264             : 
     265          35 : void MIDI_Pipe::stallUpstream(MIDIStaller *cause, MIDI_Sink *stallsrc) {
     266          35 :     if (stallsrc == sink) {
     267             :         // This cannot be a different cause, because then our sink would
     268             :         // already have caught it in stallDownstream().
     269           9 :         sink_staller = cause;
     270           9 :         if (hasSource())
     271           9 :             source->stallUpstream(cause, this);
     272           9 :         if (hasThroughIn())
     273           1 :             getThroughIn()->stallUpstream(cause, this);
     274             :     } else {
     275          26 :         if (through_staller == nullptr) {
     276          17 :             through_staller = cause;
     277          17 :             if (hasSource())
     278          17 :                 source->stallUpstream(cause, this);
     279             :         }
     280             :     }
     281          35 : }
     282             : 
     283          41 : void MIDI_Pipe::unstallDownstream(MIDIStaller *cause, MIDI_Source *stallsrc) {
     284          41 :     if (!sinkIsUnstalledOrStalledBy(cause)) {
     285           1 :         FATAL_ERROR(F("Cannot unstall pipe from ")
     286             :                         << MIDIStaller::getNameNull(cause)
     287             :                         << F(" because pipe is stalled by ")
     288             :                         << MIDIStaller::getNameNull(sink_staller),
     289             :                     0x6666);
     290             :     } // LCOV_EXCL_LINE
     291          40 :     this->sink_staller = nullptr;
     292          40 :     if (hasThroughOut() && stallsrc == source)
     293           1 :         getThroughOut()->unstallDownstream(cause, this);
     294          40 :     if (hasSink())
     295          40 :         sink->unstallDownstream(cause, this);
     296          40 :     if (hasSource() && source != stallsrc) {
     297          18 :         source->unstallUpstream(cause, this);
     298             :         // If the through output of this pipe is stalled, we cannot just unstall
     299             :         // our upstream, we have to update it our through output staller
     300          18 :         if (through_staller != nullptr)
     301           4 :             source->stallUpstream(through_staller, this);
     302             :     }
     303          40 :     if (hasThroughIn() && getThroughIn() != stallsrc)
     304           7 :         getThroughIn()->unstallUpstream(cause, this);
     305          40 : }
     306             : 
     307          25 : void MIDI_Pipe::unstallUpstream(MIDIStaller *cause, MIDI_Sink *stallsrc) {
     308          25 :     if (stallsrc == sink) {
     309             :         // This cannot be a different cause, because then our sink would
     310             :         // already have caught it in unstallDownstream().
     311           8 :         sink_staller = nullptr;
     312           8 :         if (hasSource())
     313           8 :             source->unstallUpstream(cause, this);
     314           8 :         if (hasThroughIn())
     315           1 :             getThroughIn()->unstallUpstream(cause, this);
     316             :     } else {
     317          17 :         if (cause == through_staller) {
     318          11 :             through_staller = nullptr;
     319          11 :             if (hasSource())
     320          11 :                 source->unstallUpstream(cause, this);
     321             :         }
     322             :     }
     323          25 : }
     324             : 
     325           4 : const char *MIDI_Pipe::getSinkStallerName() const {
     326           4 :     return MIDIStaller::getNameNull(sink_staller);
     327             : }
     328             : 
     329           2 : const char *MIDI_Pipe::getThroughStallerName() const {
     330           2 :     return MIDIStaller::getNameNull(through_staller);
     331             : }
     332             : 
     333          21 : MIDIStaller *MIDI_Pipe::getStaller() const {
     334          21 :     return sink_staller ? sink_staller : through_staller;
     335             : }
     336             : 
     337           3 : const char *MIDI_Pipe::getStallerName() const {
     338           3 :     return MIDIStaller::getNameNull(getStaller());
     339             : }
     340             : 
     341         151 : void MIDI_Pipe::handleStallers() const {
     342         151 :     if (!isStalled())
     343         143 :         return;
     344           8 :     if (sink_staller == eternal_stall || through_staller == eternal_stall)
     345           1 :         FATAL_ERROR(F("Unable to unstall pipe (eternal stall)"), 0x4827);
     346           7 :     uint8_t iterations = 10;
     347          23 :     while (isStalled() && iterations-- > 0) {
     348          16 :         if (sink_staller)
     349          15 :             sink_staller->handleStall();
     350          16 :         if (through_staller)
     351           1 :             through_staller->handleStall();
     352             :     }
     353             : }
     354             : 
     355             : // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: //
     356             : 
     357          18 : const char *MIDIStaller::getNameNull(MIDIStaller *s) {
     358          18 :     if (s == nullptr)
     359           4 :         return "(null)";
     360          14 :     if (s == eternal_stall)
     361           1 :         return "(eternal stall)";
     362          13 :     return s->getName();
     363             : }
     364             : 
     365             : END_CS_NAMESPACE
     366             : 
     367             : #endif