direct_array_buffer.h

Go to the documentation of this file.

#pragma once

#include "buffer.h"
#include <cstring>
#include <algorithm>

BEGIN_NAMESPACE_MEMORY

template <typename T, typename Locking = UseLock>
class IDirectArraySourceBuffer : public ISourceBuffer<T>
{
    static_assert(std::is_trivially_copyable_v<T>, "Only trivially copyable types are supported in direct array source buffer.");

public:
    virtual T* getData() const = 0;

    virtual size_t getCapacity() const = 0;

    virtual size_t getReadPos() = 0;

    size_t readSamples(T* samples, size_t samplesCount, bool incrementPosition = true) override
    {
        return readSamplesAt(samples, samplesCount, incrementPosition, 0);
    }

    virtual size_t readSamplesAt(T* samples, size_t samplesCount, bool incrementPosition = true, size_t readOffset = 0)
    {
        LockGuard<std::recursive_mutex, Locking> guard(this->getLock());

        size_t readPos{this->getReadPos()};

        if (readOffset > 0)
        {
            readPos = (readPos + readOffset) % this->getCapacity();
            readOffset = std::min<size_t>(this->getSize(), readOffset);
        }

        samplesCount = std::min<size_t>(samplesCount, this->getSize() - readOffset);

        if (samplesCount > 0)
        {
            if (readPos + samplesCount < this->getCapacity())
            {
                read(samples, samplesCount, readPos);
            }
            else
            {
                size_t firstSamplesCount = getCapacity() - readPos;
                read(samples, firstSamplesCount, readPos);
                size_t secondSamplesCount = samplesCount - firstSamplesCount;
                read(&samples[firstSamplesCount], secondSamplesCount, 0);
            }
            if (incrementPosition)
                this->incrementReadPosition(samplesCount);
        }

        return samplesCount;
    }

protected:
    virtual size_t read(T* samples, size_t samplesCount, size_t pos)
    {
        std::memcpy(samples, &getData()[pos], samplesCount * sizeof(T));
        return samplesCount;
    }

    virtual size_t read(T* samples, size_t samplesCount)
    {
        return read(samples, samplesCount, getReadPos());
    }
};

template <typename T>
class IDirectArrayTargetBuffer : public ITargetBuffer<T>
{
    static_assert(std::is_trivially_copyable_v<T>, "Only trivially copyable types are supported in direct array target buffer.");

public:
    virtual T* getData() const = 0;

    virtual size_t getCapacity() const = 0;

    virtual size_t getWritePos() = 0;

    size_t writeSamples(const T* samples, size_t samplesCount, bool incrementPosition = true) override
    {
        std::lock_guard<std::recursive_mutex> guard(this->getLock());

        samplesCount = std::min<size_t>(samplesCount, this->getRemainingSize());

        if (samplesCount > 0)
        {
            if (getWritePos() + samplesCount <= getCapacity())
            {
                write(samples, samplesCount);
            }
            else
            {
                size_t firstSamplesCount = getCapacity() - getWritePos();
                write(samples, firstSamplesCount);
                size_t secondSamplesCount = samplesCount - firstSamplesCount;
                write(&samples[firstSamplesCount], secondSamplesCount, 0);
            }

            if (incrementPosition)
                this->incrementWritePosition(samplesCount);
        }

        return samplesCount;
    }

protected:
    virtual size_t write(const T* samples, size_t samplesCount, size_t pos)
    {
        std::memcpy(&getData()[pos], samples, samplesCount * sizeof(T));
        return samplesCount;
    }

    virtual size_t write(const T* samples, size_t samplesCount)
    {
        return write(samples, samplesCount, getWritePos());
    }
};

/*operations*/

template <typename T>
static void operator<<(IDirectArrayTargetBuffer<T>& target, ISourceBuffer<T>& source)
{
    transferBuffer(source, target);
}

template <typename T>
static void operator>>(ISourceBuffer<T>& source, IDirectArrayTargetBuffer<T>& target)
{
    transferBuffer(source, target);
}

template <typename T, typename Locking = UseLock>
size_t transferBuffer(ISourceBuffer<T>& source,
                      IDirectArrayTargetBuffer<T>& target,
                      bool incrementPosition = true,
                      size_t samplesCount = (std::numeric_limits<size_t>::max)())
{
    LockGuard<std::recursive_mutex, Locking> guardS(source.getLock());
    LockGuard<std::recursive_mutex, Locking> guardT(target.getLock());

    samplesCount = std::min<size_t>(std::min<size_t>(samplesCount, source.getSize()), target.getRemainingSize());

    if (samplesCount > 0)
    {
        if (target.getWritePos() + samplesCount <= target.getCapacity())
        {
            source.readSamples(&target.getData()[target.getWritePos()], samplesCount, incrementPosition);
        }
        else
        {
            size_t firstSamplesCount = target.getCapacity() - target.getWritePos();
            source.readSamples(&target.getData()[target.getWritePos()], firstSamplesCount, incrementPosition);
            size_t secondSamplesCount = samplesCount - firstSamplesCount;
            source.readSamples(target.getData(), secondSamplesCount, incrementPosition);
        }

        if (incrementPosition)
            target.incrementWritePosition(samplesCount);
    }

    return samplesCount;
}

template <typename T>
static void operator<<(ISourceBuffer<T>& target, IDirectArrayTargetBuffer<T>& source)
{
    transferBuffer(source, target);
}

template <typename T>
static void operator>>(IDirectArrayTargetBuffer<T>& source, ISourceBuffer<T>& target)
{
    transferBuffer(source, target);
}

template <typename T>
size_t transferBuffer(IDirectArraySourceBuffer<T>& source,
                      ITargetBuffer<T>& target,
                      bool incrementPosition = true,
                      size_t samplesCount = (std::numeric_limits<size_t>::max)(),
                      bool earlyReleaseSourceLock = false)
{
    std::unique_lock<std::recursive_mutex> guardS(source.getLock());
    size_t sourceSize = source.getSize();
    size_t sourceCapacity = source.getCapacity();
    size_t sourceReadPos = source.getReadPos();

    if (earlyReleaseSourceLock)
        guardS.unlock();

    std::lock_guard<std::recursive_mutex> guardT(target.getLock());

    samplesCount = std::min<size_t>(std::min<size_t>(samplesCount, sourceSize), target.getRemainingSize());

    if (samplesCount > 0)
    {
        if (sourceReadPos + samplesCount <= sourceCapacity)
        {
            target.writeSamples(&source.getData()[sourceReadPos], samplesCount, incrementPosition);
        }
        else
        {
            size_t firstSamplesCount = sourceCapacity - sourceReadPos;
            target.writeSamples(&source.getData()[sourceReadPos], firstSamplesCount, incrementPosition);
            size_t secondSamplesCount = samplesCount - firstSamplesCount;
            target.writeSamples(source.getData(), secondSamplesCount, incrementPosition);
        }

        if (incrementPosition)
            source.incrementReadPosition(samplesCount);
    }

    return samplesCount;
}

template <typename T>
static void operator<<(IDirectArraySourceBuffer<T>& target, IDirectArrayTargetBuffer<T>& source)
{
    transferBuffer(source, target);
}

template <typename T>
static void operator>>(IDirectArrayTargetBuffer<T>& source, IDirectArraySourceBuffer<T>& target)
{
    transferBuffer(source, target);
}

template <typename T>
size_t transferBuffer(IDirectArraySourceBuffer<T>& source,
                      IDirectArrayTargetBuffer<T>& target,
                      bool incrementPosition = true,
                      size_t samplesCount = (std::numeric_limits<size_t>::max)())
{
    return transferBuffer(source, static_cast<ITargetBuffer<T>&>(target), incrementPosition, samplesCount);
}

END_NAMESPACE_MEMORY