buffer.h

Go to the documentation of this file.

#pragma once

#include "memory.h"
#include <memory>
#include <mutex>
#include <cassert>
#include "lock_guard.h"

BEGIN_NAMESPACE_MEMORY

template <typename T>
class ISourceBuffer
{
public:
    virtual ~ISourceBuffer() = default;

    virtual std::recursive_mutex& getLock() = 0;

    virtual size_t getSize() = 0;

    virtual size_t readSamples(T* samples, size_t samplesCount, bool incrementPosition = true) = 0;

    virtual void incrementReadPosition(size_t pos) = 0;
};

template <typename T>
class ITargetBuffer
{
public:
    virtual ~ITargetBuffer() = default;

    virtual std::recursive_mutex& getLock() = 0;

    virtual size_t getRemainingSize() = 0;

    virtual size_t writeSamples(const T* samples, size_t samplesCount, bool incrementPosition = true) = 0;

    virtual void incrementWritePosition(size_t pos) = 0;
};

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

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

template <typename T, typename Locking = UseLock>
size_t transferBuffer(ISourceBuffer<T>& source,
                      ITargetBuffer<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());

    T* data = new T[samplesCount];
    source.readSamples(data, samplesCount, incrementPosition);
    target.writeSamples(data, samplesCount, incrementPosition);

    delete[] data;
    return samplesCount;
}

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

    assert(sizeof(S) % sizeof(T) == 0 || sizeof(T) % sizeof(S) == 0);

    size_t fS = (sizeof(S) > sizeof(T)) ? sizeof(S) / sizeof(T) : 1;
    size_t fT = (sizeof(S) < sizeof(T)) ? sizeof(T) / sizeof(S) : 1;

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

    std::unique_ptr<T[]> data(new T[samplesCount * fS]);
    source.readSamples((S*) data.get(), samplesCount * fT, incrementPosition);
    target.writeSamples(data.get(), samplesCount * fS, incrementPosition);

    return samplesCount;
}

END_NAMESPACE_MEMORY