source/utils/Lv2AtomRingBuffer.hpp

   1 /*
   2  * LV2 Atom Ring Buffer
   3  * Copyright (C) 2012-2023 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 LV2_ATOM_RING_BUFFER_HPP_INCLUDED
  19 #define LV2_ATOM_RING_BUFFER_HPP_INCLUDED
  20
  21 #include "CarlaMutex.hpp"
  22 #include "CarlaRingBuffer.hpp"
  23
  24 #include "lv2/atom.h"
  25
  26 // --------------------------------------------------------------------------------------------------------------------
  27
  28 class Lv2AtomRingBuffer : public CarlaRingBufferControl<HeapBuffer>
  29 {
  30 public:
  31     Lv2AtomRingBuffer() noexcept
  32         : fMutex(),
  33           fHeapBuffer{0, 0, 0, 0, false, nullptr},
  34           fNeedsDataDelete(true)
  35     {
  36     }
  37
  38     Lv2AtomRingBuffer(Lv2AtomRingBuffer& ringBuf, uint8_t buf[]) noexcept
  39         : fMutex(),
  40           fHeapBuffer{0, 0, 0, 0, false, nullptr},
  41           fNeedsDataDelete(false)
  42     {
  43         fHeapBuffer.buf  = buf;
  44         fHeapBuffer.size = ringBuf.fHeapBuffer.size;
  45
  46         {
  47             const CarlaMutexLocker cml(ringBuf.fMutex);
  48             fHeapBuffer.copyDataFrom(ringBuf.fHeapBuffer);
  49             ringBuf.clearData();
  50         }
  51
  52         setRingBuffer(&fHeapBuffer, false);
  53     }
  54
  55     ~Lv2AtomRingBuffer() noexcept
  56     {
  57         if (fHeapBuffer.buf == nullptr || ! fNeedsDataDelete)
  58             return;
  59
  60         delete[] fHeapBuffer.buf;
  61         fHeapBuffer.buf = nullptr;
  62     }
  63
  64     // ----------------------------------------------------------------------------------------------------------------
  65
  66     void createBuffer(const uint32_t size, const bool mlock) noexcept
  67     {
  68         CARLA_SAFE_ASSERT_RETURN(fHeapBuffer.buf == nullptr,);
  69         CARLA_SAFE_ASSERT_RETURN(fNeedsDataDelete,);
  70         CARLA_SAFE_ASSERT_RETURN(size > 0,);
  71
  72         const uint32_t p2size = carla_nextPowerOf2(size);
  73
  74         try {
  75             fHeapBuffer.buf = new uint8_t[p2size];
  76         } CARLA_SAFE_EXCEPTION_RETURN("Lv2AtomRingBuffer::createBuffer",);
  77
  78         fHeapBuffer.size = p2size;
  79         setRingBuffer(&fHeapBuffer, true);
  80
  81         if (mlock)
  82         {
  83             carla_mlock(&fHeapBuffer, sizeof(fHeapBuffer));
  84             carla_mlock(fHeapBuffer.buf, p2size);
  85         }
  86     }
  87
  88     void deleteBuffer() noexcept
  89     {
  90         CARLA_SAFE_ASSERT_RETURN(fHeapBuffer.buf != nullptr,);
  91         CARLA_SAFE_ASSERT_RETURN(fNeedsDataDelete,);
  92
  93         setRingBuffer(nullptr, false);
  94
  95         delete[] fHeapBuffer.buf;
  96         fHeapBuffer.buf  = nullptr;
  97         fHeapBuffer.size = 0;
  98     }
  99
 100     uint32_t getSize() const noexcept
 101     {
 102         return fHeapBuffer.size;
 103     }
 104
 105     // ----------------------------------------------------------------------------------------------------------------
 106
 107     bool tryLock() const noexcept
 108     {
 109         return fMutex.tryLock();
 110     }
 111
 112     void unlock() const noexcept
 113     {
 114         fMutex.unlock();
 115     }
 116
 117     // ----------------------------------------------------------------------------------------------------------------
 118
 119     // NOTE: must have been locked before
 120     bool get(uint32_t& portIndex, LV2_Atom* const retAtom) noexcept
 121     {
 122         if (readAtom(portIndex, retAtom))
 123             return true;
 124
 125         retAtom->size = retAtom->type = 0;
 126         return false;
 127     }
 128
 129     // NOTE: must NOT been locked, we do that here
 130     bool put(const LV2_Atom* const atom, const uint32_t portIndex) noexcept
 131     {
 132         CARLA_SAFE_ASSERT_RETURN(atom != nullptr && atom->size > 0, false);
 133
 134         const CarlaMutexLocker cml(fMutex);
 135
 136         return writeAtom(atom, static_cast<int32_t>(portIndex));
 137     }
 138
 139     // NOTE: must NOT been locked, we do that here
 140     bool putChunk(const LV2_Atom* const atom, const void* const data, const uint32_t portIndex) noexcept
 141     {
 142         CARLA_SAFE_ASSERT_RETURN(atom != nullptr && atom->size > 0, false);
 143         CARLA_SAFE_ASSERT_RETURN(data != nullptr, false);
 144
 145         const CarlaMutexLocker cml(fMutex);
 146
 147         return writeAtomChunk(atom, data, static_cast<int32_t>(portIndex));
 148     }
 149
 150 protected:
 151     // ----------------------------------------------------------------------------------------------------------------
 152
 153     bool readAtom(uint32_t& portIndex, LV2_Atom* const retAtom) noexcept
 154     {
 155         const uint32_t maxAtomSize = retAtom->size - sizeof(LV2_Atom);
 156
 157         LV2_Atom atom = {};
 158
 159         if (! tryRead(&atom, sizeof(LV2_Atom)))
 160             return false;
 161         if (atom.size == 0 || atom.type == 0)
 162             return false;
 163
 164         CARLA_SAFE_ASSERT_UINT2_RETURN(atom.size < maxAtomSize, atom.size, maxAtomSize, false);
 165
 166         int32_t index = -1;
 167         if (! tryRead(&index, sizeof(int32_t)))
 168             return false;
 169         if (index < 0)
 170             return false;
 171
 172         if (! tryRead(retAtom + 1, atom.size))
 173             return false;
 174
 175         portIndex = static_cast<uint32_t>(index);
 176         retAtom->size = atom.size;
 177         retAtom->type = atom.type;
 178         return true;
 179     }
 180
 181     // ----------------------------------------------------------------------------------------------------------------
 182
 183     bool writeAtom(const LV2_Atom* const atom, const int32_t portIndex) noexcept
 184     {
 185         if (tryWrite(atom, sizeof(LV2_Atom)) && tryWrite(&portIndex, sizeof(int32_t)))
 186             tryWrite(LV2_ATOM_BODY_CONST(atom), atom->size);
 187         return commitWrite();
 188     }
 189
 190     bool writeAtomChunk(const LV2_Atom* const atom, const void* const data, const int32_t portIndex) noexcept
 191     {
 192         if (tryWrite(atom, sizeof(LV2_Atom)) && tryWrite(&portIndex, sizeof(int32_t)))
 193             tryWrite(data, atom->size);
 194         return commitWrite();
 195     }
 196
 197     // ----------------------------------------------------------------------------------------------------------------
 198
 199 private:
 200     CarlaMutex fMutex;
 201     HeapBuffer fHeapBuffer;
 202     const bool fNeedsDataDelete;
 203
 204     friend class Lv2AtomQueue;
 205
 206     CARLA_PREVENT_VIRTUAL_HEAP_ALLOCATION
 207     CARLA_DECLARE_NON_COPYABLE(Lv2AtomRingBuffer)
 208 };
 209
 210 // --------------------------------------------------------------------------------------------------------------------
 211
 212 #endif // LV2_ATOM_RING_BUFFER_HPP_INCLUDED