NDArray.h

Go to the documentation of this file.

#ifndef NDArray_H
#define NDArray_H

#include <set>
#include <epicsMutex.h>
#include <epicsTime.h>
#include <stdio.h>

#include "NDAttribute.h"
#include "NDAttributeList.h"
#include "Codec.h"

#define ND_ARRAY_MAX_DIMS 10

typedef enum
{
    NDColorModeMono,    
    NDColorModeBayer,   
    NDColorModeRGB1,    
    NDColorModeRGB2,    
    NDColorModeRGB3,    
    NDColorModeYUV444,  
    NDColorModeYUV422,  
    NDColorModeYUV411   
} NDColorMode_t;

typedef enum
{
    NDBayerRGGB        = 0,    
    NDBayerGBRG        = 1,    
    NDBayerGRBG        = 2,    
    NDBayerBGGR        = 3     
} NDBayerPattern_t;

typedef struct NDDimension {
    size_t size;    
    size_t offset;  
    int binning;    
    int reverse;    
} NDDimension_t;

typedef struct NDArrayInfo {
    size_t nElements;       
    int bytesPerElement;    
    size_t totalBytes;      
    NDColorMode_t colorMode; 
    int xDim;               
    int yDim;               
    int colorDim;           
    size_t xSize;           
    size_t ySize;           
    size_t colorSize;       
    size_t xStride;         
    size_t yStride;         
    size_t colorStride;     
} NDArrayInfo_t;

class epicsShareClass NDArray {
public:
    /* Methods */
    NDArray();
    NDArray(int ndims, size_t *dims, NDDataType_t dataType, size_t dataSize, void *pData);
    virtual ~NDArray();
    int          initDimension   (NDDimension_t *pDimension, size_t size);
    static int   computeArrayInfo(int ndims, size_t *dims, NDDataType_t dataType, NDArrayInfo *pInfo);
    int          getInfo         (NDArrayInfo_t *pInfo);
    int          reserve();
    int          release();
    int          getReferenceCount() const {return referenceCount;}
    int          report(FILE *fp, int details);
    friend class NDArrayPool;
    
private:
    ELLNODE      node;              
    int          referenceCount;    
public:
    class NDArrayPool *pNDArrayPool;  
    class asynNDArrayDriver *pDriver; 
    int           uniqueId;     
    double        timeStamp;    
    epicsTimeStamp epicsTS;     
    int           ndims;        
    NDDimension_t dims[ND_ARRAY_MAX_DIMS]; 
    NDDataType_t  dataType;     
    size_t        dataSize;     
    void          *pData;       
    NDAttributeList *pAttributeList;  
    Codec_t codec;              
    size_t compressedSize;      
};

// This class defines the object that is contained in the std::multilist for sorting NDArrays in the freeList_.
// It defines the < operator to use the NDArray::dataSize field as the sort key

// We would like to hide this class definition in NDArrayPool.cpp and just forward reference it here.
// That works on Visual Studio, and on gcc if instantiating plugins as heap variables with "new", but fails on gcc
// if instantiating plugins as automatic variables.
//class sortedListElement;

class freeListElement {
    public:
        freeListElement(NDArray *pArray, size_t dataSize) {
          pArray_ = pArray;
          dataSize_ = dataSize;}
        friend bool operator<(const freeListElement& lhs, const freeListElement& rhs) {
            return (lhs.dataSize_ < rhs.dataSize_);
        }
        NDArray *pArray_;
        size_t dataSize_;
    private:
        freeListElement(); // Default constructor is private so objects cannot be constructed without arguments
};

class epicsShareClass NDArrayPool {
public:
    NDArrayPool  (class asynNDArrayDriver *pDriver, size_t maxMemory);
    virtual ~NDArrayPool() {}
    NDArray*     alloc(int ndims, size_t *dims, NDDataType_t dataType, size_t dataSize, void *pData);
    NDArray*     copy(NDArray *pIn, NDArray *pOut, bool copyData, bool copyDimensions=true, bool copyDataType=true);

    int          reserve(NDArray *pArray);
    int          release(NDArray *pArray);
    int          convert(NDArray *pIn,
                         NDArray **ppOut,
                         NDDataType_t dataTypeOut,
                         NDDimension_t *outDims);
    int          convert(NDArray *pIn,
                         NDArray **ppOut,
                         NDDataType_t dataTypeOut);
    int          report(FILE  *fp, int details);
    int          getNumBuffers();
    size_t       getMaxMemory();
    size_t       getMemorySize();
    int          getNumFree();
    void         emptyFreeList();

protected:
    virtual NDArray* createArray();
    virtual void onAllocateArray(NDArray *pArray);
    virtual void onReserveArray(NDArray *pArray);
    virtual void onReleaseArray(NDArray *pArray);

private:
    std::multiset<freeListElement> freeList_;
    epicsMutexId listLock_;      
    int          numBuffers_;
    size_t       maxMemory_;     
    size_t       memorySize_;    
    class asynNDArrayDriver *pDriver_; 
};

#endif