source/utils/CarlaEngineUtils.hpp

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