Image.h

Go to the documentation of this file.

/*
 * Image.h
 *
 *  Created on: May 2, 2014
 *      Author: mitycam
 */
 
#ifndef IMAGE_H_
#define IMAGE_H_
 
#include <cstring>
#include <cstdlib>
 
#include "Utility/RAMStreamer.h"
 
#include "Utility/Types.h"
#include "IOCallback.h"
 
#include "CameraTypes.h"
 
typedef struct {
    uint16 mnFrameWidth;
    uint16 mnFrameHeight;
    uint16 mnColOffset;
    uint16 mnRowOffset;
    uint32 mnFrameIndex;
    uint32 mnTimestamp;
    uint32 mnSlowTimestamp;
    uint32 mnReserved5;
    uint32 mnReserved6;
    uint32 mnReserved7;
} tsFrameHeader;
 
class tcImage
{
private:
    static const int32_t gnMAX_IMAGE_SIZE_BYTES = 1024*1024*100; 
 
    uint16 *mpDataVector;  
    int32 mnWidth;         
    int32 mnHeight;        
 
    void unpack32bit(uint32 *apData, int32 anWidth, int32 anHeight)
    {
        int32 cntr = 0;
        for(int i = 0; i < anWidth*anHeight;) {
            mpDataVector[i++] = ((apData[cntr] & (0x00000FFF)));
            mpDataVector[i++] = ((apData[cntr] & (0x00FFF000)) >> 12);
            mpDataVector[i++] = ((apData[cntr] & (0xFF000000)) >> 24) | ((apData[cntr + 1] & (0x0000000F)) << 8);
            cntr++;
            mpDataVector[i++] = ((apData[cntr] & (0x0000FFF0)) >> 4);
            mpDataVector[i++] = ((apData[cntr] & (0x0FFF0000)) >> 16);
            mpDataVector[i++] = ((apData[cntr] & (0xF0000000)) >> 28) | ((apData[cntr + 1] & (0x000000FF)) << 4);
            cntr++;
            mpDataVector[i++] = ((apData[cntr] & (0x000FFF00)) >> 8);
            mpDataVector[i++] = ((apData[cntr] & (0xFFF00000)) >> 20);
            cntr++;
        }
    }
 
    void unpack16bit(uint16 *apData, int32 anWidth, int32 anHeight)
    {
        uint16 word = 0;
        int8 method = 0;
        int32 cntr = 0;
        for(int i = 0; i < anWidth*anHeight; i++) {
            if(method == 0) {
                // 0th word, get the left aligned pixel.
                word = ((apData[cntr] & (0x0FFF)));
            } else if(method == 1) {
                // 1st word, get the nibble + byte
                word = ((apData[cntr] & (0xF000)) >> 12) | ((apData[cntr + 1] & (0xFF)) << 4);
                ++cntr;
            } else if(method == 2) {
                word = ((apData[cntr] & (0xFF00)) >> 8) | ((apData[cntr + 1] & (0xF)) << 8);
                ++cntr;
            } else if(method == 3) {
                word = ((apData[cntr] & (0xFFF0)) >> 4);
                ++cntr;
            }
            method = (method + 1) % 4; //Wrap every 4 words
 
            mpDataVector[i] = word;
        }
    }
 
    void alloc_and_unpack(unsigned char* apData, int32_t anWidth,
                  int32_t anHeight, tcRAMStreamer::tePackingMode aePacking)
    {
        switch(aePacking) {
            default:
            case tcRAMStreamer::eeMono16:
            {
                int num_bytes = sizeof(uint16_t)*anWidth*anHeight;
                mpDataVector = (uint16_t*)malloc(num_bytes);
                if (mpDataVector)
                    memcpy(mpDataVector, apData, num_bytes);
                break;
            }
            case tcRAMStreamer::eeMono12packed:
            {
                // we will unpack to a 16 bit buffer
                int num_bytes = sizeof(uint16_t)*anWidth*anHeight;
                mpDataVector = (uint16_t*)malloc(num_bytes);
                if (mpDataVector)
                    unpack16bit((uint16_t*)apData, anWidth, anHeight);
                break;
            }
            case tcRAMStreamer::eeMono12p: /* GigE format? Not supported */
                break;
 
            case tcRAMStreamer::eeMono8p:
            {
                // we will unpack to an 8 bit buffer
                int num_bytes = sizeof(uint8_t)*anWidth*anHeight;
                mpDataVector = (uint16_t*)malloc(num_bytes);
                if (mpDataVector)
                    memcpy(mpDataVector, apData, num_bytes);
                break;
            }
        }
    }
 
public:
    tcImage(void *apAddr, int anNumBytes, int32 anWidth, int32 anHeight,
        tcRAMStreamer::tePackingMode aePacking = tcRAMStreamer::eeMono16,
        bool abHasHeader = false)
    : mnWidth(anWidth), mnHeight(anHeight), mbOwnData(anNumBytes)
    {
        unsigned char* lpData = (unsigned char*)apAddr;
 
        if(abHasHeader) {
            memcpy(&msFrameHeader, lpData, sizeof(tsFrameHeader));
 
            // Increment the address
            lpData = lpData + sizeof(tsFrameHeader);
 
        } else {
            memset(&msFrameHeader, 0, sizeof(msFrameHeader));
        }
        mpDataVector = (reinterpret_cast<uint16 *>(lpData));
         if (!mnWidth) mnWidth = msFrameHeader.mnFrameWidth;
        if (!mnHeight) mnHeight = msFrameHeader.mnFrameHeight;
 
        /* if anNumBytes is non-zero, allocate and unpack data buffer */
        if (anNumBytes) {
            alloc_and_unpack(lpData, mnWidth, mnHeight, aePacking);
        }
 
    }
 
    tcImage(void *apAddr, tcRAMStreamer::tePackingMode aePacking)
    : mpDataVector(NULL)
    {
        unsigned char* lpData = (unsigned char*)apAddr;
        memcpy(&msFrameHeader, lpData, sizeof(tsFrameHeader));
        mnWidth = msFrameHeader.mnFrameWidth;
        mnHeight = msFrameHeader.mnFrameHeight;
        // sanity check the header
        lpData = lpData + sizeof(tsFrameHeader);
        if (mnWidth * mnHeight * 2 <= gnMAX_IMAGE_SIZE_BYTES)
            alloc_and_unpack(lpData, mnWidth, mnHeight, aePacking);
    }
 
    virtual ~tcImage()
    {
        if(mbOwnData)
            free(mpDataVector);
    }
 
    uint16_t* data()
    {
        return mpDataVector;
    }
 
    const uint16_t* data() const
    {
        return mpDataVector;
    }
 
    uint8_t* data8()
    {
        return (uint8_t*)mpDataVector;
    }
    const uint8_t* data8() const
    {
        return (const uint8_t*)mpDataVector;
    }
 
    int32_t getWidth() const
    {
        return mnWidth;
    }
 
    int32_t getHeight() const
    {
        return mnHeight;
    }
 
    tsFrameHeader getFrameHeader() const {
        return msFrameHeader;
    }
 
private:
    tsFrameHeader msFrameHeader; 
    bool mbOwnData; 
};
 
#endif /* IMAGE_H_ */