EDDImageDataSource.cpp

Go to the documentation of this file.

#include <EDDSourceLib/inc/EDDImageDataSource.h>
#include <EDDSourceLib/inc/EDDMsgLoop.h>
#include <proto/EDDImageDataMsg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if defined(WIN32)
#define snprintf sprintf_s
#else
using namespace std;
#endif

static char* maFields[] =
{
    "DESC",
    "X",
    "Y",
    "Z"
};
        
tcEDDImageDataSource::tcEDDImageDataSource(char* apDesc)
: tcEDDDataSource()
, mnImageNo(0)
, mpOutputBuffer(0)
, mnOutputBufferLen(0)
{
    // initialize labels, etc.
    strncpy(maDescription, apDesc, gnMaxStringLen);
    snprintf(maXLabel, gnMaxStringLen, "X");    
    snprintf(maYLabel, gnMaxStringLen, "Y");    
    snprintf(maZLabel, gnMaxStringLen, "Z"); 
       
    // register with message loop
    RegisterWithMsgLoop();
}
        
tcEDDImageDataSource::~tcEDDImageDataSource(void)
{
    UnRegisterWithMsgLoop();
    if (NULL != mpOutputBuffer)
    {
        delete [] mpOutputBuffer;
    }
}
        
int 
tcEDDImageDataSource::HandleMsg(tsEDDMsgHdr* apMsg)
{
    int rv = EDDMSG_OK;
    switch(apMsg->mnMsgId)
    {
        case EDDMSGID_SOURCEDESCREQMSG:
            {
                char* maDescData[4];
                maDescData[0] = maDescription;
                maDescData[1] = maXLabel;
                maDescData[2] = maYLabel;
                maDescData[3] = maZLabel;
                SendSourceDescMsg(maFields, maDescData, 4);
            }
            break;
        default:
            rv = EDDMSG_UNHANDLED;
            break;
    }
    return rv;
}

void 
tcEDDImageDataSource::BuildOutputBuffer(void)
{
    int maxlen = tcEDDMsgLoop::GetInstance()->GetMaxMessageLen(mnSourceId);
    if (maxlen < 0) maxlen = 1400;
    if (mnOutputBufferLen < maxlen)
    {
        mnOutputBufferLen = maxlen;
        if (NULL != mpOutputBuffer)
        {
            delete [] mpOutputBuffer;
        }
        mpOutputBuffer = new char[mnOutputBufferLen];
    }
}

void
tcEDDImageDataSource::SendImageDescriptor(uint16_t anRows, uint16_t anCols, uint8_t anType, uint8_t anFlags)
{
    tsEDDImageDescMsg* lpDescMsg = (tsEDDImageDescMsg*)mpOutputBuffer;
    // TODO -- lpDescMsg->msTimeStamp;
    lpDescMsg->mnImageNumber = mnImageNo;
    lpDescMsg->mnImageType   = anType;
    lpDescMsg->mnNumRows     = anRows;
    lpDescMsg->mnNumCols     = anCols;
    lpDescMsg->mnFlags       = anFlags;
    lpDescMsg->mnOffset[0]   = 0.0;
    lpDescMsg->mnOffset[1]   = 0.0;
    lpDescMsg->mnScale[0]    = 1.0;
    lpDescMsg->mnScale[1]    = 1.0;
    BuildHeader(&lpDescMsg->msHeader, EDDMSGID_IMAGEDESCMSG, sizeof(tsEDDImageDescMsg));
    tcEDDMsgLoop::GetInstance()->SendMsg(&lpDescMsg->msHeader);

}

int 
tcEDDImageDataSource::SendSparseImageData(uint16_t anDefault, uint16_t anRows, uint16_t anCols,
                                              uint32_t* apImageOffset, uint16_t* apValue, uint16_t anNumPts,
                                              uint8_t anType)
{
    return SendSparseData((void*)&anDefault, anRows, anCols, apImageOffset, apValue, anNumPts, sizeof(uint16_t), anType);
}                                             

int 
tcEDDImageDataSource::SendSparseImageData(uint8_t anDefault, uint16_t anRows, uint16_t anCols,
                                              uint32_t* apImageOffset, uint8_t* apValue, uint16_t anNumPts,
                                              uint8_t anType)
{
    return SendSparseData((void*)&anDefault, anRows, anCols, apImageOffset, apValue, anNumPts, sizeof(uint8_t), anType);    
}                                            

int
tcEDDImageDataSource::SendSparseData(void* apDefault, uint16_t anRows, uint16_t anCols,
                                         uint32_t* apImageOffset, void* apValue, uint16_t anNumPts,
                                         int WordSizeBytes, uint8_t anType)
{
    int rv = 0;
    
    // if no-one is subscribed, don't bother building messages only to throw them on the floor...
    if (!IsSubscribed())
    {
       return rv;
    }

    BuildOutputBuffer();
    
    // Send Image Descriptor
    SendImageDescriptor(anRows, anCols, anType, EDDIMGFLAGS_SPARSE);

    // Send Sparse Image Data
    unsigned int MaxPixelsPerMsg = (mnOutputBufferLen-sizeof(tsEDDImageMsg)-WordSizeBytes) / (WordSizeBytes+sizeof(uint32_t));
    unsigned int pixels_sent = 0;
    while(pixels_sent < anNumPts)
    {
        tsEDDImageMsg* lpImageMsg    = (tsEDDImageMsg*)mpOutputBuffer;
        lpImageMsg->mnTotalPixels    = anNumPts;
        lpImageMsg->mnImageNumber    = mnImageNo;
        if (anNumPts-pixels_sent > MaxPixelsPerMsg)
        {
            lpImageMsg->mnNumPixels  = MaxPixelsPerMsg;
            lpImageMsg->mnStartPixel = pixels_sent;
        }
        else
        {
            lpImageMsg->mnNumPixels  = anNumPts-pixels_sent;
            lpImageMsg->mnStartPixel = anNumPts;
        }
        char* lpData = (char*)(lpImageMsg+1);
        // copy the offsets
        memcpy(lpData, apImageOffset+pixels_sent, sizeof(uint32_t)*lpImageMsg->mnNumPixels);
        lpData += sizeof(uint32_t)*lpImageMsg->mnNumPixels;
        // copy the values
        memcpy(lpData, (char*)apValue+pixels_sent*WordSizeBytes, WordSizeBytes*lpImageMsg->mnNumPixels);
        lpData += WordSizeBytes*lpImageMsg->mnNumPixels;
        // copy the default value
        memcpy(lpData, apDefault, WordSizeBytes);
        BuildHeader(&lpImageMsg->msHeader, EDDMSGID_IMAGEMSG, 
                    sizeof(tsEDDImageMsg)+WordSizeBytes*(1+lpImageMsg->mnNumPixels)+lpImageMsg->mnNumPixels*sizeof(uint32_t));
        tcEDDMsgLoop::GetInstance()->SendMsg(&lpImageMsg->msHeader);
        pixels_sent += lpImageMsg->mnNumPixels;
    }
    mnImageNo++;
        
    return rv;    
    
}                                        

int 
tcEDDImageDataSource::SendImageData(uint8_t* apData, uint16_t anRows, uint16_t anCols, uint8_t anType)
{
    return Send3DData(apData, anRows, anCols, sizeof(uint8_t), anType); 
}

int 
tcEDDImageDataSource::SendImageData(uint16_t* apData, uint16_t anRows, uint16_t anCols, uint8_t anType)
{   
    return Send3DData(apData, anRows, anCols, sizeof(uint16_t), anType); 
}

int
tcEDDImageDataSource::Send3DData(void* apData, uint16_t anRows, uint16_t anCols, int WordSizeBytes, uint8_t anDataType)
{
    int rv = 0;
    
    // if no-one is subscribed, don't bother building messages only to throw them on the floor...
    if (!IsSubscribed())
    {
       return rv;
    }

    BuildOutputBuffer();
    
    // Send Image Descriptor
    SendImageDescriptor(anRows, anCols, anDataType, 0);
    
    // Send Image Data
    unsigned int MaxPixelsPerMsg = (mnOutputBufferLen-sizeof(tsEDDImageMsg)) / WordSizeBytes;
    unsigned int pixels_sent = 0;
    unsigned int total_pixels = anRows*anCols;
    while(pixels_sent < total_pixels)
    {
        tsEDDImageMsg* lpImageMsg    = (tsEDDImageMsg*)mpOutputBuffer;
        lpImageMsg->mnTotalPixels    = total_pixels;
        lpImageMsg->mnStartPixel     = pixels_sent;
        lpImageMsg->mnImageNumber    = mnImageNo;
        if (total_pixels-pixels_sent > MaxPixelsPerMsg)
        {
            lpImageMsg->mnNumPixels = MaxPixelsPerMsg;
        }
        else
        {
            lpImageMsg->mnNumPixels = total_pixels-pixels_sent;
        }
        void *lpData = (void*)(lpImageMsg+1);
        memcpy(lpData, (char*)apData+pixels_sent*WordSizeBytes, lpImageMsg->mnNumPixels*WordSizeBytes);
        BuildHeader(&lpImageMsg->msHeader, EDDMSGID_IMAGEMSG, 
                    sizeof(tsEDDImageMsg)+WordSizeBytes*lpImageMsg->mnNumPixels);
        tcEDDMsgLoop::GetInstance()->SendMsg(&lpImageMsg->msHeader);
        pixels_sent += lpImageMsg->mnNumPixels;
    }
    mnImageNo++;
        
    return rv;
    
}
        
int 
tcEDDImageDataSource::SetLabel(teAxis aeAxis, char* apLabel)
{
    char* lpPtr;
    switch (aeAxis)
    {
        case eeX:
            lpPtr = &maXLabel[0];
            break;
        case eeY:
            lpPtr = &maYLabel[0];
            break;
        case eeZ:
        default:
            lpPtr = &maZLabel[0];
            break;
    }
    strncpy(lpPtr, apLabel, gnMaxStringLen);
    return 0;
}

int 
tcEDDImageDataSource::SetDescription(char* apDesc)
{
    strncpy(maDescription, apDesc, gnMaxStringLen);
    return 0;
}

---