source/utils/CarlaEngineUtils.hpp

   1 // SPDX-FileCopyrightText: 2011-2024 Filipe Coelho <falktx@falktx.com>
   2 // SPDX-License-Identifier: GPL-2.0-or-later
   3
   4 #ifndef CARLA_ENGINE_UTILS_HPP_INCLUDED
   5 #define CARLA_ENGINE_UTILS_HPP_INCLUDED
   6
   7 #include "CarlaEngine.hpp"
   8 #include "CarlaUtils.hpp"
   9 #include "CarlaMIDI.h"
  10
  11 #include "water/midi/MidiBuffer.h"
  12
  13 CARLA_BACKEND_START_NAMESPACE
  14
  15 // -----------------------------------------------------------------------
  16 // Maximum internal pre-allocated events
  17
  18 const ushort kMaxEngineEventInternalCount = 2048;
  19
  20 // -----------------------------------------------------------------------
  21
  22 static inline
  23 const char* EngineType2Str(const EngineType type) noexcept
  24 {
  25     switch (type)
  26     {
  27     case kEngineTypeNull:
  28         return "kEngineTypeNull";
  29     case kEngineTypeJack:
  30         return "kEngineTypeJack";
  31     case kEngineTypeRtAudio:
  32         return "kEngineTypeRtAudio";
  33     case kEngineTypeSDL:
  34         return "kEngineTypeSDL";
  35     case kEngineTypePlugin:
  36         return "kEngineTypePlugin";
  37     case kEngineTypeBridge:
  38         return "kEngineTypeBridge";
  39     case kEngineTypeDummy:
  40         return "kEngineTypeDummy";
  41     }
  42
  43     carla_stderr("CarlaBackend::EngineType2Str(%i) - invalid type", type);
  44     return nullptr;
  45 }
  46
  47 static inline
  48 const char* EnginePortType2Str(const EnginePortType type) noexcept
  49 {
  50     switch (type)
  51     {
  52     case kEnginePortTypeNull:
  53         return "kEnginePortTypeNull";
  54     case kEnginePortTypeAudio:
  55         return "kEnginePortTypeAudio";
  56     case kEnginePortTypeCV:
  57         return "kEnginePortTypeCV";
  58     case kEnginePortTypeEvent:
  59         return "kEnginePortTypeEvent";
  60     }
  61
  62     carla_stderr("CarlaBackend::EnginePortType2Str(%i) - invalid type", type);
  63     return nullptr;
  64 }
  65
  66 static inline
  67 const char* EngineEventType2Str(const EngineEventType type) noexcept
  68 {
  69     switch (type)
  70     {
  71     case kEngineEventTypeNull:
  72         return "kEngineEventTypeNull";
  73     case kEngineEventTypeControl:
  74         return "kEngineEventTypeControl";
  75     case kEngineEventTypeMidi:
  76         return "kEngineEventTypeMidi";
  77     }
  78
  79     carla_stderr("CarlaBackend::EngineEventType2Str(%i) - invalid type", type);
  80     return nullptr;
  81 }
  82
  83 static inline
  84 const char* EngineControlEventType2Str(const EngineControlEventType type) noexcept
  85 {
  86     switch (type)
  87     {
  88     case kEngineControlEventTypeNull:
  89         return "kEngineNullEvent";
  90     case kEngineControlEventTypeParameter:
  91         return "kEngineControlEventTypeParameter";
  92     case kEngineControlEventTypeMidiBank:
  93         return "kEngineControlEventTypeMidiBank";
  94     case kEngineControlEventTypeMidiProgram:
  95         return "kEngineControlEventTypeMidiProgram";
  96     case kEngineControlEventTypeAllSoundOff:
  97         return "kEngineControlEventTypeAllSoundOff";
  98     case kEngineControlEventTypeAllNotesOff:
  99         return "kEngineControlEventTypeAllNotesOff";
 100     }
 101
 102     carla_stderr("CarlaBackend::EngineControlEventType2Str(%i) - invalid type", type);
 103     return nullptr;
 104 }
 105
 106 // -----------------------------------------------------------------------
 107
 108 static inline
 109 void fillEngineEventsFromWaterMidiBuffer(EngineEvent engineEvents[kMaxEngineEventInternalCount], const water::MidiBuffer& midiBuffer)
 110 {
 111     const uint8_t* midiData;
 112     int numBytes, sampleNumber;
 113     ushort engineEventIndex = 0;
 114
 115     for (ushort i=0; i < kMaxEngineEventInternalCount; ++i)
 116     {
 117         const EngineEvent& engineEvent(engineEvents[i]);
 118
 119         if (engineEvent.type != kEngineEventTypeNull)
 120             continue;
 121
 122         engineEventIndex = i;
 123         break;
 124     }
 125
 126     for (water::MidiBuffer::Iterator midiBufferIterator(midiBuffer); midiBufferIterator.getNextEvent(midiData, numBytes, sampleNumber) && engineEventIndex < kMaxEngineEventInternalCount;)
 127     {
 128         CARLA_SAFE_ASSERT_CONTINUE(numBytes > 0);
 129         CARLA_SAFE_ASSERT_CONTINUE(sampleNumber >= 0);
 130         CARLA_SAFE_ASSERT_CONTINUE(numBytes < 0xFF /* uint8_t max */);
 131
 132         EngineEvent& engineEvent(engineEvents[engineEventIndex++]);
 133
 134         engineEvent.time = static_cast<uint32_t>(sampleNumber);
 135         engineEvent.fillFromMidiData(static_cast<uint8_t>(numBytes), midiData, 0);
 136     }
 137 }
 138
 139 // -----------------------------------------------------------------------
 140
 141 static inline
 142 void fillWaterMidiBufferFromEngineEvents(water::MidiBuffer& midiBuffer, const EngineEvent engineEvents[kMaxEngineEventInternalCount])
 143 {
 144     uint8_t size     = 0;
 145     uint8_t mdata[3] = { 0, 0, 0 };
 146     uint8_t mdataTmp[EngineMidiEvent::kDataSize];
 147     const uint8_t* mdataPtr;
 148
 149     for (ushort i=0; i < kMaxEngineEventInternalCount; ++i)
 150     {
 151         const EngineEvent& engineEvent(engineEvents[i]);
 152
 153         /**/ if (engineEvent.type == kEngineEventTypeNull)
 154         {
 155             break;
 156         }
 157         else if (engineEvent.type == kEngineEventTypeControl)
 158         {
 159             const EngineControlEvent& ctrlEvent(engineEvent.ctrl);
 160
 161             size = ctrlEvent.convertToMidiData(engineEvent.channel, mdata);
 162             mdataPtr = mdata;
 163         }
 164         else if (engineEvent.type == kEngineEventTypeMidi)
 165         {
 166             const EngineMidiEvent& midiEvent(engineEvent.midi);
 167
 168             size = midiEvent.size;
 169             CARLA_SAFE_ASSERT_CONTINUE(size > 0);
 170
 171             if (size > EngineMidiEvent::kDataSize)
 172             {
 173                 CARLA_SAFE_ASSERT_CONTINUE(midiEvent.dataExt != nullptr);
 174                 mdataPtr = midiEvent.dataExt;
 175             }
 176             else
 177             {
 178                 // set first byte
 179                 mdataTmp[0] = static_cast<uint8_t>(midiEvent.data[0] | (engineEvent.channel & MIDI_CHANNEL_BIT));
 180
 181                 if (size > 1)
 182                 {
 183                     // copy rest
 184                     carla_copy<uint8_t>(mdataTmp+1, midiEvent.data+1, size-1U);
 185                 }
 186
 187                 // done
 188                 mdataPtr = mdataTmp;
 189             }
 190         }
 191         else
 192         {
 193             continue;
 194         }
 195
 196         if (size > 0)
 197             midiBuffer.addEvent(mdataPtr, static_cast<int>(size), static_cast<int>(engineEvent.time));
 198     }
 199 }
 200
 201 // -------------------------------------------------------------------
 202 // Helper classes
 203
 204 class ScopedEngineEnvironmentLocker
 205 {
 206 public:
 207       ScopedEngineEnvironmentLocker(CarlaEngine* const engine) noexcept;
 208       ~ScopedEngineEnvironmentLocker() noexcept;
 209
 210 private:
 211     CarlaEngine::ProtectedData* const pData;
 212
 213     CARLA_PREVENT_HEAP_ALLOCATION
 214     CARLA_DECLARE_NON_COPYABLE(ScopedEngineEnvironmentLocker)
 215 };
 216
 217 // -----------------------------------------------------------------------
 218
 219 CARLA_BACKEND_END_NAMESPACE
 220
 221 #endif // CARLA_ENGINE_UTILS_HPP_INCLUDED