NDArray.h

Go to the documentation of this file.

 
#ifndef NDArray_H
#define NDArray_H
 
#include <set>
 
#include <epicsMutex.h>
#include <epicsTime.h>
#include <ellLib.h>
 
#include "NDAttribute.h"
#include "NDAttributeList.h"
#include "Codec.h"
 
#define ND_ARRAY_MAX_DIMS 10
 
typedef void *(*MallocFunc_t)(size_t size);
typedef void (*FreeFunc_t)(void *ptr);
extern MallocFunc_t defaultFrameMalloc;
extern FreeFunc_t defaultFrameFree;
 
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 ADCORE_API 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 ADCORE_API 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();
    static void  setDefaultFrameMemoryFunctions(MallocFunc_t newMalloc,
                                                FreeFunc_t newFree);
    virtual void* frameMalloc(size_t size);
    virtual void frameFree(void *ptr);
 
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