I am currently working on designing a video buffer in C ++ that will be used by many consumers, both in the native library space (C ++) and on the Java side at the same time. 39, JNI help. My idea is:
have a buffer manager that will receive the frames directly from the hardware and allocate each frame only once on the heap with the help of a shared pointer if it is at least aware of the ########################################################################## 39, a consumer for this frame. when a consumer wants to receive a video frame, he calls the link method and specifies the size of the desired buffer because not all of them process the data at the same rate. It is therefore best to have a dedicated buffer for each customer / consumer. after binding, the buffer manager returns a DataBufferStream object that will be used by the consumer to read / extract video images. the DataBufferStram class is nothing more than a circular buffer of a certain type and size. Using JNI im schedule to pass a pointer to the buffer or copy the data into an array of bytes
I would like to have some comments from people here to see if there is anything I can improve. Is there a better solution that you can recommend
class BufferManager {
public:
std::shared_ptr> bind(const unsigned int bufferSize,const int
requestorID);
void unbind(const int requestorID);
std::shared_ptr getInstance();
private:
std::map>> mDataBufferMap;
std::mutex mMutex;
};
std::shared_ptr> BufferManager::bind(const unsigned int
bufferSize,const int requestorID) {
std::lock_guard lockGuard(mMutex);
auto it = mDataBufferMap.find(requestorID);
if(it == mDataBufferMap.end()){
mDataBufferMap(requestorID) = std::make_shared>(bufferSize);
}
return mDataBufferMap(requestorID);
}
void BufferManager::unbind(const int requestorID) {
std::lock_guard lock(mMutex);
mDataBufferMap.erase(requestorID);
}
`
#include "../include/boost/circular_buffer.hpp"
#include
#include
#include
#include
typedef boost::shared_array SHARED_ARRAY;
template
class DataBufferStream {
private:
boost::circular_buffer mCircularBuffer;
std::mutex mMutex;
std::condition_variable mConditionalVariable;
unsigned int mIndex;
public:
DataBufferStream(const unsigned int bufferSize);
DataBufferStream(DataBufferStream& other);
DataBufferStream() = delete;
virtual ~DataBufferStream();
void pushData(T data);
T fetchData();
T readData(unsigned int duration);
T operator()(const unsigned int index);
T operator*();
void operator++();
void operator--();
DataBufferStream &operator=(DataBufferStream& other);
void clear();
unsigned int size();
};
`
#include "DataBuffer.h"
template
DataBufferStream::DataBufferStream(const unsigned int bufferSize):
mCircularBuffer(bufferSize),
mMutex(),
mConditionalVariable(),
mIndex(0)
{
}
template
T DataBufferStream::fetchData() {
std::lock_guard lock (mMutex);
if(mCircularBuffer.size()>0) {
auto ptr = mCircularBuffer.front();
mCircularBuffer.pop_front();
return ptr;
}
return nullptr;
}
template
void DataBufferStream::pushData(T data) {
std::lock_guard lock (mMutex);
mCircularBuffer.push_back(data);
mConditionalVariable.notify_all();
}
template
T DataBufferStream::operator()(const unsigned int index) {
std::lock_guard lock (mMutex);
return mCircularBuffer.size()>index ? mCircularBuffer(index) : nullptr;
}
template
DataBufferStream::~DataBufferStream() {
}
template
T DataBufferStream::operator*() {
std::lock_guard lock(mMutex);
return mCircularBuffer.size() > mIndex ? mCircularBuffer(mIndex) : nullptr;
}
template
void DataBufferStream::operator++() {
std::lock_guard lock(mMutex);
mIndex = mCircularBuffer.size() < mIndex+1 ? 0 : mIndex++;
}
template
void DataBufferStream::operator--() {
std::lock_guard lock(mMutex);
mIndex = mIndex > 0 ? mIndex-- : 0;
}
template
void DataBufferStream::clear() {
std::lock_guard lock(mMutex);
mCircularBuffer.clear();
mIndex = mCircularBuffer.size();
}
template
DataBufferStream::DataBufferStream(DataBufferStream &other):
mMutex(),
mConditionalVariable(){
std::lock_guard lock(other.mMutex);
this->mCircularBuffer = other.mCircularBuffer;
this->mIndex = other.mIndex;
}
template
DataBufferStream &DataBufferStream::operator=(DataBufferStream &other) {
if(this!=&other){
std::unique_lock myLock (mMutex,std::defer_lock);
std::unique_lock otherLock(other.mMutex,std::defer_lock);
std::lock(myLock,otherLock);
mCircularBuffer = other.mCircularBuffer;
mIndex = other.mIndex;
}
return *this;
}
template
unsigned int DataBufferStream::size() {
std::lock_guard lock(mMutex);
return mCircularBuffer.size();
}
template
T DataBufferStream::readData(unsigned int duration) {
auto data = fetchData();
std::unique_lock lock(mMutex);
if((data == nullptr) &&
(mConditionalVariable.wait_for(lock,std::chrono::milliseconds(duration)) ==
std::cv_status::no_timeout)){
if(mCircularBuffer.size()>0) {
auto data = mCircularBuffer.front();
mCircularBuffer.pop_front();
}
}
return data;
}
template class DataBufferStream;
