BlockBuffer.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GTK+ IOStream is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You have received a copy of the GNU General Public License
   along with GTK+ IOStream
*/
#ifndef BLOCKBUFFER_H_
#define BLOCKBUFFER_H_

#include <queue>
#include <Thread.H>
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wignored-attributes"
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include <Eigen/Dense>
#pragma GCC diagnostic pop

#define BLOCK_BUFFER_DEFAULT_COUNT 3

class BlockBuffer {
    std::vector<Eigen::Array<unsigned short, Eigen::Dynamic, Eigen::Dynamic> > buffers; 
    std::queue<Eigen::Array<unsigned short, Eigen::Dynamic, Eigen::Dynamic> *> emptyBuffers; 
    std::queue<Eigen::Array<unsigned short, Eigen::Dynamic, Eigen::Dynamic> *> fullBuffers; 

    Mutex fullBufferMutex; 
    Mutex emptyBufferMutex; 

    void init(int count) {
        buffers.resize(count);
        for (int c=0; c<count; c++)
            emptyBuffers.push(&buffers[c]);
    }
public:
    BlockBuffer(int count) {
        init(count);
    }

    BlockBuffer(void) {
        init(BLOCK_BUFFER_DEFAULT_COUNT);
    }

    Eigen::Array<unsigned short, Eigen::Dynamic, Eigen::Dynamic> *getEmptyBuffer(void){
        Eigen::Array<unsigned short, Eigen::Dynamic, Eigen::Dynamic> *retBuf=NULL;
        emptyBufferMutex.lock();
        if (emptyBuffers.size()){
            retBuf=emptyBuffers.front();
            emptyBuffers.pop();
        }
        emptyBufferMutex.unLock();
        return retBuf;
    }

    Eigen::Array<unsigned short, Eigen::Dynamic, Eigen::Dynamic> *getFullBuffer(void){
        Eigen::Array<unsigned short, Eigen::Dynamic, Eigen::Dynamic> *retBuf=NULL;
        fullBufferMutex.lock();
        if (fullBuffers.size()){
            retBuf=fullBuffers.front();
            fullBuffers.pop();
        }
        fullBufferMutex.unLock();
        return retBuf;
    }

    void putFullBuffer(Eigen::Array<unsigned short, Eigen::Dynamic, Eigen::Dynamic> *fb){
        fullBufferMutex.lock();
        fullBuffers.push(fb);
        fullBufferMutex.unLock();
    }

    void putEmptyBuffer(Eigen::Array<unsigned short, Eigen::Dynamic, Eigen::Dynamic> *eb){
        emptyBufferMutex.lock();
        emptyBuffers.push(eb);
        emptyBufferMutex.unLock();
    }

    int getBufferCount(){
        return buffers.size();
    }

    void resizeBuffers(int rows, int cols){
        emptyBufferMutex.lock();
        fullBufferMutex.lock();
        for (int i=0; i<buffers.size(); i++)
            buffers[i].resize(rows, cols);
        emptyBufferMutex.unLock();
        fullBufferMutex.unLock();
    }

    void resize(int count){
        buffers.resize(count);
        int rows=0, cols=0;
        // find the current matrix sizes and mimick - try either a full or empty buffer. All should be the same.
        Eigen::Array<unsigned short, Eigen::Dynamic, Eigen::Dynamic> *b=getFullBuffer();
        if (!b)
            b=getEmptyBuffer();
        if (b) {
            rows=b->rows();
            cols=b->cols();
        }

        // remove any existing pointers
        while ((b=getFullBuffer())!=NULL);
        while ((b=getEmptyBuffer())!=NULL);

        // create all of the buffers and set them up as empty.
        emptyBufferMutex.lock();
        fullBufferMutex.lock();
        init(count);
        emptyBufferMutex.unLock();
        fullBufferMutex.unLock();
        resizeBuffers(rows, cols);
    }

// IF you plan to use a class which inherits from a stl container, then this will conflict, leaving out for now.
//    /** Return a pointer to one of the buffers in the buffer vector which contains all buffers in constant disorder.
//    \param i The i'th buffer to index from the buffer vector (0 <= i < getBufferCount()).
//    \return A pointer to the i'th buffer or NULL on failure.
//    */
//    Eigen::DenseBase<Derived> *operator[](int i){
//        if (i<buffers.size() & i>=0)
//            return &buffers[i];
//        return NULL;
//    }
};

#endif // BLOCKBUFFER_H_