falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Browse Source

Rename some vars

tags/1.9.4
falkTX 12 years ago
parent
61c03055ba
commit
f3be639b11
5 changed files with 92 additions and 92 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +3
    -3
      source/backend/engine/CarlaEngineBridge.cpp
  2. +3
    -3
      source/backend/plugin/BridgePlugin.cpp
  3. +1
    -1
      source/utils/CarlaBridgeUtils.hpp
  4. +56
    -56
      source/utils/CarlaRingBuffer.hpp
  5. +29
    -29
      source/utils/Lv2AtomQueue.hpp

+ 3
- 3
source/backend/engine/CarlaEngineBridge.cpp View File

@@ -97,13 +97,13 @@ struct BridgeAudioPool {
CARLA_DECLARE_NON_COPY_STRUCT(BridgeAudioPool)
};

struct BridgeControl : public RingBufferControl<StackRingBuffer> {
struct BridgeControl : public RingBufferControl<StackBuffer> {
CarlaString filename;
BridgeShmControl* data;
char shm[32];

BridgeControl()
: RingBufferControl<StackRingBuffer>(nullptr),
: RingBufferControl<StackBuffer>(nullptr),
data(nullptr)
{
carla_zeroChar(shm, 32);
@@ -141,7 +141,7 @@ struct BridgeControl : public RingBufferControl<StackRingBuffer> {

if (jackbridge_shm_map2<BridgeShmControl>(shm, data))
{
setRingBuffer(&data->ringBuffer, false);
setRingBuffer(&data->buffer, false);
return true;
}



+ 3
- 3
source/backend/plugin/BridgePlugin.cpp View File

@@ -146,14 +146,14 @@ struct BridgeAudioPool {
CARLA_DECLARE_NON_COPY_STRUCT(BridgeAudioPool)
};

struct BridgeControl : public RingBufferControl<StackRingBuffer> {
struct BridgeControl : public RingBufferControl<StackBuffer> {
CarlaString filename;
CarlaRecursiveMutex lock;
BridgeShmControl* data;
shm_t shm;

BridgeControl()
: RingBufferControl<StackRingBuffer>(nullptr),
: RingBufferControl<StackBuffer>(nullptr),
data(nullptr)
{
carla_shm_init(shm);
@@ -189,7 +189,7 @@ struct BridgeControl : public RingBufferControl<StackRingBuffer> {

if (carla_shm_map<BridgeShmControl>(shm, data))
{
setRingBuffer(&data->ringBuffer, true);
setRingBuffer(&data->buffer, true);
return true;
}



+ 1
- 1
source/utils/CarlaBridgeUtils.hpp View File

@@ -97,7 +97,7 @@ struct BridgeShmControl {
void* runClient;
char _padClient[32];
};
StackRingBuffer ringBuffer;
StackBuffer buffer;
};

// -----------------------------------------------------------------------


+ 56
- 56
source/utils/CarlaRingBuffer.hpp View File

@@ -23,13 +23,13 @@
// -----------------------------------------------------------------------
// RingBuffer structs

struct HeapRingBuffer {
struct HeapBuffer {
uint32_t size;
int32_t head, tail, written;
bool invalidateCommit;
char* buf;

HeapRingBuffer& operator=(const HeapRingBuffer& rb) noexcept
HeapBuffer& operator=(const HeapBuffer& rb) noexcept
{
CARLA_SAFE_ASSERT_RETURN(size == rb.size, *this);

@@ -44,7 +44,7 @@ struct HeapRingBuffer {
}
};

struct StackRingBuffer {
struct StackBuffer {
static const uint32_t size = 4096;
int32_t head, tail, written;
bool invalidateCommit;
@@ -54,12 +54,12 @@ struct StackRingBuffer {
// -----------------------------------------------------------------------
// RingBufferControl templated class

template <class RingBufferStruct>
template <class BufferStruct>
class RingBufferControl
{
public:
RingBufferControl(RingBufferStruct* const ringBuf) noexcept
: fRingBuf(ringBuf)
RingBufferControl(BufferStruct* const ringBuf) noexcept
: fBuffer(ringBuf)
{
if (ringBuf != nullptr)
clear();
@@ -67,23 +67,23 @@ public:

void clear() noexcept
{
CARLA_SAFE_ASSERT_RETURN(fRingBuf != nullptr,);
CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);

fRingBuf->head = 0;
fRingBuf->tail = 0;
fRingBuf->written = 0;
fRingBuf->invalidateCommit = false;
fBuffer->head = 0;
fBuffer->tail = 0;
fBuffer->written = 0;
fBuffer->invalidateCommit = false;

if (fRingBuf->size > 0)
carla_zeroChar(fRingBuf->buf, fRingBuf->size);
if (fBuffer->size > 0)
carla_zeroChar(fBuffer->buf, fBuffer->size);
}

void setRingBuffer(RingBufferStruct* const ringBuf, const bool reset) noexcept
void setRingBuffer(BufferStruct* const ringBuf, const bool reset) noexcept
{
CARLA_SAFE_ASSERT_RETURN(ringBuf != nullptr,);
CARLA_SAFE_ASSERT_RETURN(ringBuf != fRingBuf,);
CARLA_SAFE_ASSERT_RETURN(ringBuf != fBuffer,);

fRingBuf = ringBuf;
fBuffer = ringBuf;

if (reset)
clear();
@@ -93,26 +93,26 @@ public:

bool commitWrite() noexcept
{
CARLA_SAFE_ASSERT_RETURN(fRingBuf != nullptr, false);
CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr, false);

if (fRingBuf->invalidateCommit)
if (fBuffer->invalidateCommit)
{
fRingBuf->written = fRingBuf->head;
fRingBuf->invalidateCommit = false;
fBuffer->written = fBuffer->head;
fBuffer->invalidateCommit = false;
return false;
}
else
{
fRingBuf->head = fRingBuf->written;
fBuffer->head = fBuffer->written;
return true;
}
}

bool isDataAvailable() const noexcept
{
CARLA_SAFE_ASSERT_RETURN(fRingBuf != nullptr, false);
CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr, false);

return (fRingBuf->head != fRingBuf->tail);
return (fBuffer->head != fBuffer->tail);
}

// -------------------------------------------------------------------
@@ -179,25 +179,25 @@ public:
protected:
void tryRead(void* const buf, const size_t size) noexcept
{
CARLA_SAFE_ASSERT_RETURN(fRingBuf != nullptr,);
CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);
CARLA_SAFE_ASSERT_RETURN(buf != nullptr,);
CARLA_SAFE_ASSERT_RETURN(size != 0,);
CARLA_SAFE_ASSERT_RETURN(size < fRingBuf->size,);
CARLA_SAFE_ASSERT_RETURN(size < fBuffer->size,);

// this should not happen
CARLA_ASSERT(fRingBuf->head >= 0);
CARLA_ASSERT(fRingBuf->tail >= 0);
CARLA_ASSERT(fRingBuf->written >= 0);
CARLA_ASSERT(fBuffer->head >= 0);
CARLA_ASSERT(fBuffer->tail >= 0);
CARLA_ASSERT(fBuffer->written >= 0);

// empty
if (fRingBuf->head == fRingBuf->tail)
if (fBuffer->head == fBuffer->tail)
return;

char* const charbuf(static_cast<char*>(buf));

const size_t head(static_cast<size_t>(fRingBuf->head));
const size_t tail(static_cast<size_t>(fRingBuf->tail));
const size_t wrap((head < tail) ? fRingBuf->size : 0);
const size_t head(static_cast<size_t>(fBuffer->head));
const size_t tail(static_cast<size_t>(fBuffer->tail));
const size_t wrap((head < tail) ? fBuffer->size : 0);

if (head - tail + wrap < size)
{
@@ -207,65 +207,65 @@ protected:

size_t readto = tail + size;

if (readto >= fRingBuf->size)
if (readto >= fBuffer->size)
{
readto -= fRingBuf->size;
const size_t firstpart(fRingBuf->size - tail);
std::memcpy(charbuf, fRingBuf->buf + tail, firstpart);
std::memcpy(charbuf + firstpart, fRingBuf->buf, readto);
readto -= fBuffer->size;
const size_t firstpart(fBuffer->size - tail);
std::memcpy(charbuf, fBuffer->buf + tail, firstpart);
std::memcpy(charbuf + firstpart, fBuffer->buf, readto);
}
else
{
std::memcpy(charbuf, fRingBuf->buf + tail, size);
std::memcpy(charbuf, fBuffer->buf + tail, size);
}

fRingBuf->tail = static_cast<int32_t>(readto);
fBuffer->tail = static_cast<int32_t>(readto);
}

void tryWrite(const void* const buf, const size_t size) noexcept
{
CARLA_SAFE_ASSERT_RETURN(fRingBuf != nullptr,);
CARLA_SAFE_ASSERT_RETURN(fBuffer != nullptr,);
CARLA_SAFE_ASSERT_RETURN(buf != nullptr,);
CARLA_SAFE_ASSERT_RETURN(size != 0,);
CARLA_SAFE_ASSERT_RETURN(size < fRingBuf->size,);
CARLA_SAFE_ASSERT_RETURN(size < fBuffer->size,);

// this should not happen
CARLA_ASSERT(fRingBuf->head >= 0);
CARLA_ASSERT(fRingBuf->tail >= 0);
CARLA_ASSERT(fRingBuf->written >= 0);
CARLA_ASSERT(fBuffer->head >= 0);
CARLA_ASSERT(fBuffer->tail >= 0);
CARLA_ASSERT(fBuffer->written >= 0);

const char* const charbuf(static_cast<const char*>(buf));

const size_t tail(static_cast<size_t>(fRingBuf->tail));
const size_t wrtn(static_cast<size_t>(fRingBuf->written));
const size_t wrap((tail <= wrtn) ? fRingBuf->size : 0);
const size_t tail(static_cast<size_t>(fBuffer->tail));
const size_t wrtn(static_cast<size_t>(fBuffer->written));
const size_t wrap((tail <= wrtn) ? fBuffer->size : 0);

if (tail - wrtn + wrap <= size)
{
carla_stderr2("RingBufferControl::tryWrite() - buffer full!");
fRingBuf->invalidateCommit = true;
fBuffer->invalidateCommit = true;
return;
}

size_t writeto = wrtn + size;

if (writeto >= fRingBuf->size)
if (writeto >= fBuffer->size)
{
writeto -= fRingBuf->size;
const size_t firstpart(fRingBuf->size - wrtn);
std::memcpy(fRingBuf->buf + wrtn, charbuf, firstpart);
std::memcpy(fRingBuf->buf, charbuf + firstpart, writeto);
writeto -= fBuffer->size;
const size_t firstpart(fBuffer->size - wrtn);
std::memcpy(fBuffer->buf + wrtn, charbuf, firstpart);
std::memcpy(fBuffer->buf, charbuf + firstpart, writeto);
}
else
{
std::memcpy(fRingBuf->buf + wrtn, charbuf, size);
std::memcpy(fBuffer->buf + wrtn, charbuf, size);
}

fRingBuf->written = static_cast<int32_t>(writeto);
fBuffer->written = static_cast<int32_t>(writeto);
}

private:
RingBufferStruct* fRingBuf;
BufferStruct* fBuffer;

CARLA_PREVENT_HEAP_ALLOCATION
CARLA_DECLARE_NON_COPY_CLASS(RingBufferControl)


+ 29
- 29
source/utils/Lv2AtomQueue.hpp View File

@@ -25,23 +25,23 @@

// -----------------------------------------------------------------------

class Lv2AtomRingBufferControl : public RingBufferControl<HeapRingBuffer>
class Lv2AtomRingBufferControl : public RingBufferControl<HeapBuffer>
{
public:
Lv2AtomRingBufferControl() noexcept
: RingBufferControl<HeapRingBuffer>(nullptr),
: RingBufferControl<HeapBuffer>(nullptr),
fIsDummy(false)
{
fBuffer.size = 0;
fBuffer.buf = nullptr;
fLv2Buffer.size = 0;
fLv2Buffer.buf = nullptr;
}

~Lv2AtomRingBufferControl() noexcept
{
if (fBuffer.buf != nullptr && ! fIsDummy)
if (fLv2Buffer.buf != nullptr && ! fIsDummy)
{
delete[] fBuffer.buf;
fBuffer.buf = nullptr;
delete[] fLv2Buffer.buf;
fLv2Buffer.buf = nullptr;
}
}

@@ -49,38 +49,38 @@ public:

void createBuffer(const uint32_t size) noexcept
{
if (fBuffer.buf != nullptr)
if (fLv2Buffer.buf != nullptr)
{
if (! fIsDummy)
delete[] fBuffer.buf;
fBuffer.buf = nullptr;
delete[] fLv2Buffer.buf;
fLv2Buffer.buf = nullptr;
}

// shouldn't really happen please...
CARLA_SAFE_ASSERT_RETURN(size > 0,);

fBuffer.size = size;
fBuffer.buf = new char[size];
setRingBuffer(&fBuffer, true);
fLv2Buffer.size = size;
fLv2Buffer.buf = new char[size];
setRingBuffer(&fLv2Buffer, true);
}

// used for tmp buffers only
void copyDump(HeapRingBuffer& rb, char dumpBuf[]) noexcept
void copyDump(HeapBuffer& rb, char dumpBuf[]) noexcept
{
CARLA_SAFE_ASSERT_RETURN(fBuffer.size == 0,);
CARLA_SAFE_ASSERT_RETURN(fBuffer.buf == nullptr,);
fBuffer.buf = dumpBuf;
fBuffer.size = rb.size;
fBuffer.head = rb.head;
fBuffer.tail = rb.tail;
fBuffer.written = rb.written;
fBuffer.invalidateCommit = rb.invalidateCommit;
CARLA_SAFE_ASSERT_RETURN(fLv2Buffer.size == 0,);
CARLA_SAFE_ASSERT_RETURN(fLv2Buffer.buf == nullptr,);
fLv2Buffer.buf = dumpBuf;
fLv2Buffer.size = rb.size;
fLv2Buffer.head = rb.head;
fLv2Buffer.tail = rb.tail;
fLv2Buffer.written = rb.written;
fLv2Buffer.invalidateCommit = rb.invalidateCommit;
fIsDummy = true;

std::memcpy(dumpBuf, rb.buf, rb.size);

setRingBuffer(&fBuffer, false);
setRingBuffer(&fLv2Buffer, false);
}

// -------------------------------------------------------------------
@@ -132,7 +132,7 @@ public:
// -------------------------------------------------------------------

private:
HeapRingBuffer fBuffer;
HeapBuffer fLv2Buffer;
bool fIsDummy;

static const size_t kMaxDataSize = 8192;
@@ -166,12 +166,12 @@ public:

uint32_t getSize() const noexcept
{
return fRingBufferCtrl.fBuffer.size;
return fRingBufferCtrl.fLv2Buffer.size;
}

bool isEmpty() const noexcept
{
return (fRingBufferCtrl.fBuffer.buf == nullptr || !fRingBufferCtrl.isDataAvailable());
return (fRingBufferCtrl.fLv2Buffer.buf == nullptr || !fRingBufferCtrl.isDataAvailable());
}

// must have been locked before
@@ -239,7 +239,7 @@ public:
{
// copy data from source
const CarlaMutexLocker cml2(fMutex);
fRingBufferCtrl.fBuffer = queue.fRingBufferCtrl.fBuffer;
fRingBufferCtrl.fLv2Buffer = queue.fRingBufferCtrl.fLv2Buffer;
}

// clear source
@@ -254,7 +254,7 @@ public:
{
// copy data from source
const CarlaMutexLocker cml2(fMutex);
fRingBufferCtrl.copyDump(queue.fRingBufferCtrl.fBuffer, dumpBuf);
fRingBufferCtrl.copyDump(queue.fRingBufferCtrl.fLv2Buffer, dumpBuf);
}

// clear source


Write Preview
Loading…
Cancel
Save