image.h

Go to the documentation of this file.

 
#pragma once
 
#include <adtf_base.h>
#include <adtfdisplaytoolboxgraphics/color.h>
#include <adtfdisplaytoolboxgraphics/displaytbstructs.h>
#include <adtfdisplaytoolboxgraphics/image_intf.h>
 
namespace adtf
{
 
namespace disptb
{
 
namespace graphicslib
{
 
namespace dengar
{
class cColor;
 
class cImage : public IImage
{
    A_UTILS_D(cImage)
 
public:
    static tInt m_nDefaultMemoryAlignment; 
    static tInt m_nDefaultLineAlignment;   
 
protected:
    tBool m_bReference;              
 
    tBitmapFormat m_sFormat;                 
    tWin32BitmapInfo* m_psBitmapInfo;            
    tInt m_nBitmapInfoSize;         
 
    tColor* m_pPalette;                
    tUInt8* m_pBitmap;                 
    tHandle m_hBitmapMemory;           
 
    tInt m_nGreyPaletteSize;        
 
public:
    cImage();
 
    cImage(const cImage& oImage);
 
    cImage(const IImage& oImage);
 
    virtual ~cImage();
 
    tVoid Destroy();
 
    tResult Create(tInt nWidth, tInt nHeight, tInt nBitsPerPixel, tInt nBytesPerLine = 0, const tUInt8* pBitmap = nullptr,
                   tInt nPixelFormat = 0);
 
    tResult Create(const tBitmapFormat* psFormat, const tColor* pPalette = nullptr, const tUInt8* pBitmap = nullptr);
 
    tResult Attach(tUInt8* pBitmap, tInt nWidth, tInt nHeight, tInt nBitsPerPixel, tInt nBytesPerLine = 0);
 
    tResult Attach(tUInt8* pBitmap, const tBitmapFormat* psFormat, const tColor* pPalette = nullptr);
 
    tResult Load(const tChar* strFile, tUInt32 nFlags = 0);
 
    tResult Save(const tChar* strFile);
 
    tResult Release();
 
    tResult SetPixelFormat(tInt nPixelFormat);
 
    tInt GetPixelFormat() const;
 
    char const* GetPixelFormatStr() const;
 
    static tInt FlipRGBFormat(tInt nPixelFormat);
 
    static tInt FlipToBGRFormat(tInt nPixelFormat);
 
    static tInt FlipToRGBFormat(tInt nPixelFormat);
 
    tInt GetWidth() const;
 
    tInt GetHeight() const;
 
    tInt GetBitsPerPixel() const;
 
    tInt GetBytesPerLine() const;
 
    tInt GetSize() const;
 
    tFloat64 GetRatio() const;
 
    const tBitmapFormat* GetFormat() const override;
 
    tResult SetPalette(tInt nPaletteSize, const tColor* pPalette);
 
    tColor* GetPalette() const;
 
    tInt GetPaletteSize() const;
 
    tColor GetPaletteEntry(tInt nIdx) const;
 
    tResult SetPaletteEntry(tInt nIdx, const tColor& sColor);
 
    tUInt8* GetBitmap() const;
 
    tUInt8* GetBitmapLine(tInt y) const;
 
    tWin32BitmapInfo* GetBitmapInfo() override;
 
    tInt GetBitmapInfoSize();
 
    operator IImage*()
    {
            return dynamic_cast<IImage*>(this);
    }
 
public: // image manipulation
    tResult Flip();
 
    tResult Mirror();
 
    tResult Resize(tInt nWidth, tInt nHeight);
 
    tResult ChangeDepth(tInt nBitsPerPixel, tInt nBytesPerLine = 0, tUInt32 ui32Mask = 0x0);
 
    tResult Convert(tInt nWidth, tInt nHeight, tInt nBitsPerPixel, tInt nBytesPerLine = 0, tUInt32 ui32Mask = 0x0);
 
    tResult Convert(const tBitmapFormat* psFormat, tUInt32 ui32Mask = 0x0);
 
    tResult Convert(tInt oPixelFormat);
 
    tResult ChangePixelFormat(tInt nFormat, tUInt32 ui32Flags = 0);
 
    tResult FlipRGB();
 
    tResult FlipAlpha();
 
    tResult MakeAlphaChannel(const tColor& sColorKey, tBool bClearTransparent = tFalse);
 
public: // blit functions
    tResult Blit(const cImage& oDestImage, tInt nFlags = 0);
 
    tResult SetBits(const tUInt8* pSrcBitmapData, const tBitmapFormat* psSrcBitmapFormat);
 
    tResult GetBits(tUInt8* pDestBitmapData, const tBitmapFormat* psDestBitmapFormat, tInt nFlags = 0);
 
public: // static blit functions
 
    static tResult Blit(const disptb::graphicslib::dengar::cImage& oSrcImage,
                        const disptb::graphicslib::dengar::cImage& oDestImage,
                        tInt nFlags = 0);
 
    static tResult Blit(const tUInt8* pSrcBitmapData,
                        const tBitmapFormat* psSrcBitmapFormat,
                        tUInt8* pDestBitmapData,
                        const tBitmapFormat* psDestBitmapFormat,
                        tInt nFlags = 0);
 
    static tResult StretchBlit(const disptb::graphicslib::dengar::cImage& oSrcImage,
                               const disptb::graphicslib::dengar::cImage& oDestImage,
                               tInt nFlags = 0);
 
    static tResult StretchBlit(const tUInt8* pSrcBitmapData,
                               const tBitmapFormat* psSrcBitmapFormat,
                               tUInt8* pDestBitmapData,
                               const tBitmapFormat* psDestBitmapFormat,
                               tInt nFlags = 0);
 
    static tResult Convert(const tUInt8* pSrcBitmapData,
                           const tBitmapFormat* psSrcBitmapFormat,
                           tUInt8* pDestBitmapData,
                           const tBitmapFormat* psDestBitmapFormat,
                           tInt nFlags,
                           tUInt32 ui32Mask);
 
    static tResult AlphaBlend(disptb::graphicslib::dengar::cImage* pSourceImage,
                              disptb::graphicslib::dengar::cImage* pDestImage,
                              disptb::graphicslib::dengar::cImage* pMaskImage);
 
    static tResult BilinearStretchBlit(disptb::graphicslib::dengar::cImage& oSrc, disptb::graphicslib::dengar::cImage& oDest);
 
    static tResult SetTransparency(disptb::graphicslib::dengar::cImage* pImage, disptb::graphicslib::dengar::cColor oColor);
 
public: // color functions
    static inline tUInt8 RedValue(tUInt32 nColor)
    {
            return ((tUInt8) (nColor));
    };
 
    static inline tUInt8 GreenValue(tUInt32 nColor)
    {
            return ((tUInt8) (((tUInt16) (nColor)) >> 8));
    };
 
    static inline tUInt8 BlueValue(tUInt32 nColor)
    {
            return ((tUInt8) ((nColor) >> 16));
    };
 
    static inline tFloat64 Brightness(tFloat64 fRed, tFloat64 fGreen, tFloat64 fBlue)
    {
            return (0.114 * fRed + 0.587 * fGreen + 0.299 * fBlue);
    }
 
    static inline tInt BrightnessValue(tInt nRed, tInt nGreen, tInt nBlue)
    {
            return 116 * nRed + 602 * nGreen + 306 * nBlue;
    }
 
    static inline tUInt8 Brightness(tInt nRed, tInt nGreen, tInt nBlue)
    {
            return (tUInt8) (disptb::graphicslib::dengar::cImage::BrightnessValue(nRed, nGreen, nBlue) >> 10);
    }
 
    static inline tUInt8 Brightness(tColor nColor)
    {
            return (tUInt8) (disptb::graphicslib::dengar::cImage::BrightnessValue(nColor.nRed, nColor.nGreen, nColor.nBlue) >> 10);
    }
 
    static inline tUInt8 Brightness(tUInt32 nColor)
    {
            return (tUInt8) (disptb::graphicslib::dengar::cImage::BrightnessValue(RedValue(nColor), GreenValue(nColor), BlueValue(nColor)) >> 10);
    }
 
public: // helper functions
#ifdef WIN32
    tResult LoadResource(tInt nResourceId, tHandle hModule=NULL, tUInt32 nFlags=0);
    tResult CaptureScreen(tInt x, tInt y, tInt nWidth, tInt nHeight);
    tHandle CreateRegion();
#endif // WIN32
 
    tBool Compare(const disptb::graphicslib::dengar::cImage& oImage);
 
    tInt CountDifferences(const disptb::graphicslib::dengar::cImage& oImage);
 
    static tInt CalcAlignedMemSize(tInt nBytes, tInt nAlignment);
 
    static tInt GuessPixelFormat(const tBitmapFormat* pFormat);
 
    static tInt GetBitsPerPixelFromFormat(tInt nFormat);
 
    static tInt GetDefaultFormatFromBpp(tInt nBpp);
 
    static tChar const* GetPixelFormatIdentifier(const tInt nImage);
 
protected: // internal
    tResult Initialize();
 
    tResult Alloc(const tBitmapFormat* psFormat);
 
    tResult Free();
 
    tResult AllocImpl(tInt nSize, tHandle* hMemory, tVoid** pBuffer);
 
    tResult FreeImpl(tHandle hMemory);
 
    tResult AllocPalette(tInt nPaletteSize);
 
    tResult FreePalette();
 
    tResult AllocBitmapInfo();
 
    tResult FreeBitmapInfo();
 
protected: // internal blitting operations
    static tResult Blit_impl(const tUInt8* pSrcBitmapData,
                             const tBitmapFormat* psSrcBitmapFormat,
                             tUInt8* pDestBitmapData,
                             const tBitmapFormat* psDestBitmapFormat,
                             tInt nFlags);
 
    static tResult StretchBlit_impl(const tUInt8* pSrcBitmapData,
                                    const tBitmapFormat* psSrcBitmapFormat,
                                    tUInt8* pDestBitmapData,
                                    const tBitmapFormat* psDestBitmapFormat,
                                    tInt nFlags,
                                    tUInt32 ui32Mask = 0x0);
 
    static tResult Convert_impl(const tUInt8* pSrcBitmapData,
                                const tBitmapFormat* psSrcBitmapFormat,
                                tUInt8* pDestBitmapData,
                                const tBitmapFormat* psDestBitmapFormat,
                                tInt nFlags,
                                tUInt32 ui32Mask);
 
 
protected:
    /*static tResult StretchConvert_impl(const tUInt8* pSrcBitmapData,
                                       const tBitmapFormat* psSrcBitmapFormat,
                                       tUInt8* pDestBitmapData,
                                       const tBitmapFormat* psDestBitmapFormat,
                                       tInt nFlags,
                                       tUInt32 ui32Mask);*/
public:
    disptb::graphicslib::dengar::cImage& operator=(const disptb::graphicslib::dengar::cImage& oImage);
 
public:
    static int32_t GetNextPowerOfTwo(int32_t const a);
 
    static int32_t CalcBitsPerPixelFromPixelFormat(int32_t const oPixelFormat);
 
    static bool NeedAlphaBlend(int32_t const oPixelFormat);
};
 
#pragma pack(push)
#pragma pack(1)
typedef struct
{
    tUInt16 ui16Type;       
    tUInt32 ui32Size;       
    tUInt16 ui16Reserved1;  
    tUInt16 ui16Reserved2;  
    tUInt32 ui32DataOffset; 
} tBitmapFileHeader;
 
#pragma pack(pop)
}
 
using dengar::cImage;
}
 
}
 
}