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>
 
#ifdef WIN32
    #include <windows.h>
#endif
 
#ifdef max
    #undef max
#endif
#include <algorithm>
 
#ifdef GetObject
    #undef GetObject
#endif
 
namespace adtf
{
 
namespace disptb
{
 
namespace graphicslib
{
 
namespace dengar
{
class cColor;
 
#ifndef WIN32
typedef tUInt32 DWORD_PTR;
#endif // WIN32
 
#define ALPHA_DEFAULT 0
 
// Converts 8-bit R, G, and B values to 16-bit RGB565 color depth
#define RGB565(R, G, B)    (tUInt16)(((((tUInt16) B) >> 3) << 11) | ((((tUInt16) G) >> 2) << 5) | (((tUInt16) R) >> 3))
#define GetRed_RGB565(RGB) (((RGB) & 0x1F) << 3)
#define GetGreen_RGB565(RGB) ((((RGB) >> 5) & 0x3F) << 2)
#define GetBlue_RGB565(RGB)  (((RGB) >> 11) << 3)
 
#define BGR565(R, G, B)    (tUInt16)(((((tUInt16) R) >> 3) << 11) | ((((tUInt16) G) >> 2) << 5) | (((tUInt16) B) >> 3))
#define GetRed_BGR565(RGB) (((RGB) >> 11) << 3)
#define GetGreen_BGR565(RGB) ((((RGB) >> 5) & 0x3F) << 2)
#define GetBlue_BGR565(RGB)  (((RGB) & 0x1F) << 3)
 
#define RGB555(R, G, B)    (tUInt16)(((((tUInt16) B) >> 3) << 10) | ((((tUInt16) G) >> 3) << 5) | (((tUInt16) R) >> 3))
#define GetRed_RGB555(RGB) (((RGB) & 0x1F) << 3)
#define GetGreen_RGB555(RGB) ((((RGB) >> 5) & 0x1F) << 3)
#define GetBlue_RGB555(RGB)  (((RGB) >> 10) << 3)
 
#define BGR555(R, G, B)    (tUInt16)(((((tUInt16) R) >> 3) << 10) | ((((tUInt16) G) >> 3) << 5) | (((tUInt16) B) >> 3))
#define GetRed_BGR555(RGB) (((RGB) >> 10) << 3)
#define GetGreen_BGR555(RGB) ((((RGB) >> 5) & 0x1F) << 3)
#define GetBlue_BGR555(RGB)  (((RGB) & 0x1F) << 3)
 
#define RGBA4444(R, G, B, A)                                                                             \
    (tUInt16)(((((tUInt16) A) >> 4) << 12) | ((((tUInt16) B) >> 4) << 8) | ((((tUInt16) G) >> 4) << 4) | \
              (((tUInt16) R) >> 4))
#define GetRed_RGBA4444(RGB)   (((RGB) & 0xf) << 4)
#define GetGreen_RGBA4444(RGB) ((RGB) & 0xf0)
#define GetBlue_RGBA4444(RGB)  (((RGB) & 0xf00) >> 4)
#define GetAlpha_RGBA4444(RGB) (((RGB) & 0xf000) >> 8)
 
#define ABGR4444(R, G, B, A)                                                                             \
    (tUInt16)(((((tUInt16) R) >> 4) << 12) | ((((tUInt16) G) >> 4) << 8) | ((((tUInt16) B) >> 4) << 4) | \
              (((tUInt16) A) >> 4))
#define GetRed_ABGR4444(RGB)   (((RGB) & 0xf000) >> 8)
#define GetGreen_ABGR4444(RGB) (((RGB) & 0xf00) >> 4)
#define GetBlue_ABGR4444(RGB)  ((RGB) & 0xf0)
#define GetAlpha_ABGR4444(RGB) (((RGB) & 0xf) << 4)
 
#define GET_REMAINDER(v, v1, v2, max) ((((max) + 1) * (v) * (v2)) / (v1) - ((max) + 1) * (((v) * (v2)) / (v1)))
 
#pragma pack(push)
#pragma pack(1)
typedef struct
{
    tUInt16 ui16Type; 
    tUInt32 ui32Size; 
    tUInt16 ui16Reserved1; 
    tUInt16 ui16Reserved2; 
    tUInt32 ui32DataOffset; 
} tBitmapFileHeader;
 
#pragma pack(pop)

class cImage : public IImage
{
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()
    {
        Initialize();
    }

    cImage(const cImage& oImage): cImage(static_cast<const IImage&>(oImage))
    {
    }

    cImage(const IImage& oImage)
    {
        Initialize();
        Create(oImage.GetWidth(), oImage.GetHeight(), oImage.GetBitsPerPixel(), oImage.GetBytesPerLine(),
               oImage.GetBitmap(), oImage.GetPixelFormat());
    }

    virtual ~cImage()
    {
        Free();
    }

    tVoid Destroy()
    {
        delete this;
    }

    tResult Create(tInt nWidth,
                   tInt nHeight,
                   tInt nBitsPerPixel,
                   tInt nBytesPerLine = 0,
                   const tUInt8* pBitmap = nullptr,
                   tInt nPixelFormat = 0)
    {
        Release();
 
        tBitmapFormat l_sFormat;
 
        l_sFormat.nPixelFormat = (nPixelFormat != 0) ? static_cast<int16_t>(nPixelFormat) :
                                                       static_cast<int16_t>(GetDefaultFormatFromBpp(nBitsPerPixel));
        l_sFormat.nWidth = nWidth;
        l_sFormat.nHeight = nHeight;
        l_sFormat.nBitsPerPixel = static_cast<int16_t>(nBitsPerPixel);
        l_sFormat.nBytesPerLine = nBytesPerLine;
        if (l_sFormat.nBytesPerLine == 0)
        {
            l_sFormat.nBytesPerLine =
                CalcAlignedMemSize(l_sFormat.nWidth * l_sFormat.nBitsPerPixel / 8, m_nDefaultLineAlignment);
        }
        l_sFormat.nSize = l_sFormat.nBytesPerLine * l_sFormat.nHeight;
        l_sFormat.nPaletteSize = 0;
 
        RETURN_IF_FAILED(Create(&l_sFormat, NULL, pBitmap));
 
        RETURN_NOERROR;
    }

    tResult Create(const tBitmapFormat* psFormat, const tColor* pPalette = nullptr, const tUInt8* pBitmap = nullptr)
    {
        Release();
 
        RETURN_IF_POINTER_NULL(psFormat);
 
        RETURN_IF_FAILED(Alloc(psFormat));
 
        if (pPalette != NULL)
        {
            RETURN_IF_FAILED(SetPalette(psFormat->nPaletteSize, pPalette));
        }
        else if (psFormat->nBitsPerPixel <= 8)
        {
            // create greyscale palette
            m_sFormat.nPixelFormat = PF_GREYSCALE_8;
 
            RETURN_IF_FAILED(SetPalette((1 << 8), NULL));
        }
        else if (m_sFormat.nPixelFormat == PF_UNKNOWN)
        {
            m_sFormat.nPixelFormat = static_cast<int16_t>(GetDefaultFormatFromBpp(psFormat->nBitsPerPixel));
        }
 
        if (pBitmap != NULL)
        {
            SetBits(pBitmap, psFormat);
        }
 
        RETURN_NOERROR;
    }

    tResult Attach(tUInt8* pBitmap, tInt nWidth, tInt nHeight, tInt nBitsPerPixel, tInt nBytesPerLine = 0)
    {
        Release();
 
        RETURN_IF_POINTER_NULL(pBitmap);
 
        tBitmapFormat l_sFormat;
 
        l_sFormat.nPixelFormat = static_cast<int16_t>(GetDefaultFormatFromBpp(nBitsPerPixel));
        l_sFormat.nWidth = nWidth;
        l_sFormat.nHeight = nHeight;
        l_sFormat.nBitsPerPixel = static_cast<int16_t>(nBitsPerPixel);
        l_sFormat.nBytesPerLine = nBytesPerLine;
        if (l_sFormat.nBytesPerLine == 0)
        {
            l_sFormat.nBytesPerLine = l_sFormat.nWidth * l_sFormat.nBitsPerPixel / 8;
        }
        l_sFormat.nSize = l_sFormat.nBytesPerLine * l_sFormat.nHeight;
        l_sFormat.nPaletteSize = 0;
 
        RETURN_IF_FAILED(Attach(pBitmap, &l_sFormat, NULL));
 
        RETURN_NOERROR;
    }

    tResult Attach(tUInt8* pBitmap, const tBitmapFormat* psFormat, const tColor* pPalette = nullptr)
    {
        Release();
 
        RETURN_IF_POINTER_NULL(pBitmap);
        RETURN_IF_POINTER_NULL(psFormat);
 
        adtf::util::cMemoryBlock::MemCopy(&m_sFormat, psFormat, sizeof(m_sFormat));
        m_pBitmap = pBitmap;
        m_bReference = tTrue;
 
        if (pPalette != NULL)
        {
            RETURN_IF_FAILED(SetPalette(psFormat->nPaletteSize, pPalette));
        }
        else if (psFormat->nBitsPerPixel <= 8)
        {
            // greyscale palette
            m_sFormat.nPixelFormat = PF_GREYSCALE_8;
 
            RETURN_IF_FAILED(SetPalette((1 << 8), NULL));
        }
        else if (m_sFormat.nPixelFormat == 0)
        {
            m_sFormat.nPixelFormat = static_cast<int16_t>(GetDefaultFormatFromBpp(m_sFormat.nBitsPerPixel));
        }
 
        RETURN_NOERROR;
    }

    tResult Load(const tChar* strFile, tUInt32 nFlags = 0)
    {
        Release();
        RETURN_IF_POINTER_NULL(strFile)
        // File Format:
        // 1) tBitmapFileHeader
        // 2) tWin32BitmapInfoHeader
        // 3) Palette
        // 4) Bitmap Data
 
        adtf::util::cFile oFile;
        RETURN_IF_FAILED(oFile.Open(strFile, adtf::util::cFile::OM_Read))
 
        tBitmapFileHeader sFileHeader;
        RETURN_IF_FAILED(oFile.ReadAll(&sFileHeader, sizeof(sFileHeader)))
 
        if (sFileHeader.ui16Type != 0x4D42) // always "BM"
        {
            RETURN_ERROR(ERR_INVALID_FILE);
        }
 
        tWin32BitmapInfoHeader sBitmapHeader;
        RETURN_IF_FAILED(oFile.ReadAll(&sBitmapHeader, sizeof(sBitmapHeader)));
 
        if (sBitmapHeader.nBitCount < 8)
        {
            // file formats with a bit depth less than 8 are not supported, yet.
            RETURN_ERROR(ERR_NOT_SUPPORTED);
        }
 
        // bitmaps are always DWORD-aligned
        tUInt16 nBytesPerLine =
            static_cast<uint16_t>(CalcAlignedMemSize((sBitmapHeader.nWidth * sBitmapHeader.nBitCount) / 8, 4));
 
        RETURN_IF_FAILED(
            Create(sBitmapHeader.nWidth, sBitmapHeader.nHeight, sBitmapHeader.nBitCount, nBytesPerLine, NULL));
 
        if (sBitmapHeader.nBitCount == 8)
        {
            tInt nPaletteBytes = std::max<tInt>(m_nGreyPaletteSize, GetPaletteSize()) * sizeof(tColor);
            RETURN_IF_FAILED(oFile.ReadAll(m_pPalette, nPaletteBytes));
        }
 
        if (oFile.SetFilePos(sFileHeader.ui32DataOffset, adtf::util::cFile::FP_Begin) == -1)
        {
            RETURN_ERROR(ERR_INVALID_FILE);
        }
 
        RETURN_IF_FAILED(oFile.ReadAll(m_pBitmap, m_sFormat.nSize));
 
        // windows bitmaps are always R
        if (m_sFormat.nBitsPerPixel >= 24)
        {
            if (m_sFormat.nBitsPerPixel == 24)
            {
                m_sFormat.nPixelFormat = PF_BGR_888;
                RETURN_IF_FAILED(Convert(PF_RGB_888));
            }
            if (m_sFormat.nBitsPerPixel == 32)
            {
                m_sFormat.nPixelFormat = PF_BGRA_8888;
                RETURN_IF_FAILED(Convert(PF_RGBA_8888));
            }
 
            // this flag is ignored, since it is not longer needed
            // the bitmap is loaded now with the correct format
            // if (LF_SWAP_RGB == (nFlags & LF_SWAP_RGB))
            //{
            //    FlipRGB();
            //}
        }
 
        if (0 == (nFlags & LF_FLIP_VERTICAL))
        {
            RETURN_IF_FAILED(Flip());
        }
 
        RETURN_NOERROR;
    }

    tResult Save(const tChar* strFile)
    {
        RETURN_IF_POINTER_NULL(m_pBitmap);
 
        if (m_sFormat.nBitsPerPixel == 32)
        {
            if (m_sFormat.nPixelFormat == IImage::PF_32BIT)
            {
                m_sFormat.nPixelFormat = static_cast<int16_t>(GetDefaultFormatFromBpp(32));
            }
 
            if (m_sFormat.nPixelFormat != IImage::PF_BGRA_8888)
            {
                cImage oImg;
                oImg.Create(m_sFormat.nWidth, m_sFormat.nHeight, m_sFormat.nBitsPerPixel, m_sFormat.nBytesPerLine,
                            GetBitmap(), m_sFormat.nPixelFormat);
 
                RETURN_IF_FAILED(oImg.Convert(IImage::PF_BGRA_8888));
                return oImg.Save(strFile);
            }
        }
        else if (m_sFormat.nBitsPerPixel == 24)
        {
            if (m_sFormat.nPixelFormat == IImage::PF_24BIT)
            {
                m_sFormat.nPixelFormat = static_cast<int16_t>(GetDefaultFormatFromBpp(24));
            }
 
            if (m_sFormat.nPixelFormat != IImage::PF_BGR_888)
            {
                cImage oImg;
                oImg.Create(m_sFormat.nWidth, m_sFormat.nHeight, m_sFormat.nBitsPerPixel, m_sFormat.nBytesPerLine,
                            GetBitmap(), m_sFormat.nPixelFormat);
 
                if (m_sFormat.nPixelFormat == IImage::PF_YUV420P_888)
                {
                    RETURN_IF_FAILED(oImg.ChangePixelFormat(IImage::PF_RGB_888));
                    RETURN_IF_FAILED(oImg.Convert(IImage::PF_BGR_888));
                }
                else
                {
                    RETURN_IF_FAILED(oImg.Convert(IImage::PF_BGR_888));
                }
                return oImg.Save(strFile);
            }
        }
        else
        {
            if (m_sFormat.nPixelFormat == IImage::PF_16BIT)
            {
                m_sFormat.nPixelFormat = static_cast<int16_t>(GetDefaultFormatFromBpp(16));
            }
            else if (m_sFormat.nPixelFormat == IImage::PF_8BIT)
            {
                m_sFormat.nPixelFormat = static_cast<int16_t>(GetDefaultFormatFromBpp(8));
            }
 
            cImage oImg;
            oImg.Create(m_sFormat.nWidth, m_sFormat.nHeight, m_sFormat.nBitsPerPixel, m_sFormat.nBytesPerLine,
                        GetBitmap(), m_sFormat.nPixelFormat);
 
            RETURN_IF_FAILED(oImg.ChangePixelFormat(IImage::PF_BGR_888));
            return oImg.Save(strFile);
        }
 
        adtf::util::cFile oFile;
        tResult nResult = oFile.Open(strFile, adtf::util::cFile::OM_Write);
        if (IS_FAILED(nResult))
        {
            return nResult;
        }
 
        tInt l_nPaletteSize = m_sFormat.nPaletteSize;
        if (l_nPaletteSize == 0 && m_pPalette)
        {
            l_nPaletteSize = m_nGreyPaletteSize;
        }
 
        tInt nPaletteBytes = l_nPaletteSize * sizeof(tColor);
        tInt nBitmapBytes = m_sFormat.nSize;
 
        tBitmapFileHeader sFileHeader;
        sFileHeader.ui16Type = 0x4D42;
        sFileHeader.ui32Size =
            sizeof(tBitmapFileHeader) + sizeof(tWin32BitmapInfoHeader) + nPaletteBytes + nBitmapBytes;
        sFileHeader.ui16Reserved1 = 0;
        sFileHeader.ui16Reserved2 = 0;
        sFileHeader.ui32DataOffset = sizeof(tBitmapFileHeader) + sizeof(tWin32BitmapInfoHeader) + nPaletteBytes;
 
        nResult = oFile.WriteAll(&sFileHeader, sizeof(sFileHeader));
        if (IS_FAILED(nResult))
        {
            oFile.Close();
            return nResult;
        }
 
        tWin32BitmapInfo* pBitmapInfo = GetBitmapInfo();
        nResult = oFile.WriteAll(&pBitmapInfo->sHeader, sizeof(tWin32BitmapInfoHeader));
        if (IS_FAILED(nResult))
        {
            oFile.Close();
            return nResult;
        }
 
        if (m_pPalette)
        {
            nResult = oFile.WriteAll(m_pPalette, nPaletteBytes);
            if (IS_FAILED(nResult))
            {
                oFile.Close();
                return nResult;
            }
        }
 
        Flip();
        nResult = oFile.WriteAll(m_pBitmap, nBitmapBytes);
        Flip();
 
        oFile.Close();
        return nResult;
    }

    tResult Release()
    {
        Free();
 
        RETURN_NOERROR;
    }

    tResult SetPixelFormat(tInt nPixelFormat)
    {
        m_sFormat.nPixelFormat = static_cast<int16_t>(nPixelFormat);
 
        RETURN_NOERROR;
    }

    tInt GetPixelFormat() const
    {
        return m_sFormat.nPixelFormat;
    }

    char const* GetPixelFormatStr() const
    {
        return cImage::GetPixelFormatIdentifier(GetPixelFormat());
    }

    static tInt FlipRGBFormat(tInt nPixelFormat)
    {
        switch (nPixelFormat)
        {
            case PF_RGBA_4444: return PF_ABGR_4444;
            case PF_ABGR_4444: return PF_RGBA_4444;
            case PF_RGB_555: return PF_BGR_555;
            case PF_RGB_565: return PF_BGR_565;
            case PF_BGR_555: return PF_RGB_555;
            case PF_BGR_565: return PF_RGB_565;
            case PF_RGB_888: return PF_BGR_888;
            case PF_BGR_888: return PF_RGB_888;
            case PF_ARGB_8888: return PF_ABGR_8888;
            case PF_ABGR_8888: return PF_ARGB_8888;
            case PF_RGBA_8888: return PF_BGRA_8888;
            case PF_BGRA_8888: return PF_RGBA_8888;
            case PF_UNKNOWN: return PF_BGR_888;
        }
        return nPixelFormat;
    }

    static tInt FlipToBGRFormat(tInt nPixelFormat)
    {
        switch (nPixelFormat)
        {
            case PF_RGBA_4444: return PF_ABGR_4444;
            case PF_RGB_555: return PF_BGR_555;
            case PF_RGB_565: return PF_BGR_565;
            case PF_RGB_888: return PF_BGR_888;
            case PF_ARGB_8888: return PF_ABGR_8888;
            case PF_RGBA_8888: return PF_BGRA_8888;
            case PF_UNKNOWN: return PF_BGR_888;
        }
        return nPixelFormat;
    }

    static tInt FlipToRGBFormat(tInt nPixelFormat)
    {
        switch (nPixelFormat)
        {
            case PF_ABGR_4444: return PF_RGBA_4444;
            case PF_BGR_555: return PF_RGB_555;
            case PF_BGR_565: return PF_RGB_565;
            case PF_BGR_888: return PF_RGB_888;
            case PF_ABGR_8888: return PF_ARGB_8888;
            case PF_BGRA_8888: return PF_RGBA_8888;
            case PF_UNKNOWN: return PF_RGB_888;
        }
        return nPixelFormat;
    }

    tInt GetWidth() const
    {
        return m_sFormat.nWidth;
    }

    tInt GetHeight() const
    {
        return m_sFormat.nHeight;
    }

    tInt GetBitsPerPixel() const
    {
        return m_sFormat.nBitsPerPixel;
    }

    tInt GetBytesPerLine() const
    {
        return m_sFormat.nBytesPerLine;
    }

    tInt GetSize() const
    {
        return m_sFormat.nSize;
    }

    tFloat64 GetRatio() const
    {
        tFloat64 l_fImageRatio = 1.0;
        if (m_sFormat.nHeight != 0)
        {
            l_fImageRatio = (tFloat64) m_sFormat.nWidth / m_sFormat.nHeight;
        }
 
        return l_fImageRatio;
    }

    const tBitmapFormat* GetFormat() const override
    {
        return &m_sFormat;
    }

    tResult SetPalette(tInt nPaletteSize, const tColor* pPalette)
    {
        FreePalette();
 
        if (m_sFormat.nBitsPerPixel != 8)
        {
            RETURN_ERROR(ERR_NOT_SUPPORTED);
        }
 
        if (nPaletteSize > 0)
        {
            RETURN_IF_FAILED(AllocPalette(nPaletteSize));
 
            if (pPalette != NULL)
            {
                adtf::util::cMemoryBlock::MemCopy(m_pPalette, pPalette, nPaletteSize * sizeof(*pPalette));
 
                m_sFormat.nPixelFormat = PF_RGB_8;
                m_sFormat.nPaletteSize = nPaletteSize;
                m_nGreyPaletteSize = 0;
            }
            else
            {
                // initialize greyscale palette
                tUInt8 l_nColValue;
                for (tInt l_nIdx = 0; l_nIdx < nPaletteSize; l_nIdx++)
                {
                    l_nColValue = (tUInt8) ((l_nIdx * 255) / nPaletteSize);
                    m_pPalette[l_nIdx].nRed = m_pPalette[l_nIdx].nGreen = m_pPalette[l_nIdx].nBlue =
                        (tUInt8) l_nColValue;
                    m_pPalette[l_nIdx].nAlpha = 0;
                }
 
                m_sFormat.nPixelFormat = PF_GREYSCALE_8;
                m_sFormat.nPaletteSize = 0;
                m_nGreyPaletteSize = nPaletteSize;
            }
        }
 
        RETURN_NOERROR;
    }

    tColor* GetPalette() const
    {
        return m_pPalette;
    }

    tInt GetPaletteSize() const
    {
        return m_sFormat.nPaletteSize;
    }

    tColor GetPaletteEntry(tInt nIdx) const
    {
        if (nIdx >= 0 && nIdx < m_sFormat.nPaletteSize)
        {
            return m_pPalette[nIdx];
        }
 
        tColor l_sCol = {0, 0, 0, 0};
        return l_sCol;
    }

    tResult SetPaletteEntry(tInt nIdx, const tColor& sColor)
    {
        if (nIdx >= 0 && nIdx < m_sFormat.nPaletteSize)
        {
            m_pPalette[nIdx] = sColor;
 
            RETURN_NOERROR;
        }
 
        RETURN_ERROR(ERR_INVALID_ARG);
    }

    tUInt8* GetBitmap() const
    {
        return m_pBitmap;
    }

    tUInt8* GetBitmapLine(tInt y) const
    {
        return m_pBitmap + (y * m_sFormat.nBytesPerLine);
    }

    tWin32BitmapInfo* GetBitmapInfo() override
    {
        if (m_psBitmapInfo == NULL)
        {
            if (IS_FAILED(AllocBitmapInfo()))
            {
                return NULL;
            }
        }
 
        return m_psBitmapInfo;
    }

    tInt GetBitmapInfoSize()
    {
        if (0 == m_nBitmapInfoSize)
        {
            AllocBitmapInfo();
        }
        return m_nBitmapInfoSize;
    }

    operator IImage*()
    {
        return dynamic_cast<IImage*>(this);
    }
 
public: // image manipulation
    tResult Flip()
    {
        RETURN_IF_POINTER_NULL(m_pBitmap);
        if (m_sFormat.nHeight < 1)
        {
            RETURN_ERROR(ERR_UNEXPECTED);
        }
 
        tUInt8* pLineBuffer = new tUInt8[m_sFormat.nBytesPerLine];
        if (pLineBuffer == NULL)
        {
            RETURN_ERROR(ERR_MEMORY);
        }
 
        tInt nBytesPerLine = m_sFormat.nBytesPerLine;
 
        tUInt8* pSrc = m_pBitmap;
        tUInt8* pDest = m_pBitmap + (m_sFormat.nHeight - 1) * nBytesPerLine;
 
        while (pSrc < pDest)
        {
            // swap lines...
            adtf::util::cMemoryBlock::MemCopy(pLineBuffer, pSrc, nBytesPerLine);
            adtf::util::cMemoryBlock::MemCopy(pSrc, pDest, nBytesPerLine);
            adtf::util::cMemoryBlock::MemCopy(pDest, pLineBuffer, nBytesPerLine);
 
            pSrc += m_sFormat.nBytesPerLine;
            pDest -= m_sFormat.nBytesPerLine;
        }
 
        delete[] pLineBuffer;
        RETURN_NOERROR;
    }

    tResult Mirror()
    {
        RETURN_IF_POINTER_NULL(m_pBitmap);
        if (m_sFormat.nWidth < 2)
        {
            RETURN_ERROR(ERR_UNEXPECTED);
        }
 
        tUInt8 ui8Buf;
        tUInt16 ui16Buf;
        tUInt32 ui32Buf;
 
        tUInt8* pLeft;
        tUInt8* pRight;
        tUInt8* pLine = m_pBitmap;
        for (tInt y = 0; y < m_sFormat.nHeight; y++)
        {
            pLeft = pLine;
            pRight = pLine + ((m_sFormat.nWidth - 1) * m_sFormat.nBitsPerPixel) / 8;
 
            switch (m_sFormat.nBitsPerPixel)
            {
                case 8:
                {
                    while (pLeft < pRight)
                    {
                        ui8Buf = *pLeft;
                        *pLeft = *pRight;
                        *pRight = ui8Buf;
                        pLeft++;
                        pRight--;
                    }
                    break;
                }
                case 16:
                {
                    tUInt16* pui16Left = (tUInt16*) pLeft;
                    tUInt16* pui16Right = (tUInt16*) pRight;
                    while (pui16Left < pui16Right)
                    {
                        ui16Buf = *pui16Left;
                        *pui16Left = *pui16Right;
                        *pui16Right = ui16Buf;
 
                        pui16Left++;
                        pui16Right--;
                    }
                    break;
                }
                case 24:
                {
                    while (pLeft < pRight)
                    {
                        ui8Buf = *pLeft;
                        *pLeft = *pRight;
                        *pRight = ui8Buf;
                        pLeft++;
                        pRight++;
 
                        ui8Buf = *pLeft;
                        *pLeft = *pRight;
                        *pRight = ui8Buf;
                        pLeft++;
                        pRight++;
 
                        ui8Buf = *pLeft;
                        *pLeft = *pRight;
                        *pRight = ui8Buf;
                        pLeft++;
                        pRight++;
 
                        pRight -= 6;
                    }
                    break;
                }
                case 32:
                {
                    tUInt32* pui32Left = (tUInt32*) pLeft;
                    tUInt32* pui32Right = (tUInt32*) pRight;
                    while (pui32Left < pui32Right)
                    {
                        ui32Buf = *pui32Left;
                        *pui32Left = *pui32Right;
                        *pui32Right = ui32Buf;
 
                        pui32Left++;
                        pui32Right--;
                    }
                    break;
                }
                default:
                {
                    RETURN_ERROR(ERR_NOT_SUPPORTED);
                    break;
                }
            }
 
            pLine += m_sFormat.nBytesPerLine;
        }
        RETURN_NOERROR;
    }

    tResult Resize(tInt nWidth, tInt nHeight)
    {
        if ((nWidth < 1) || (nHeight < 1))
        {
            RETURN_ERROR(ERR_INVALID_ARG);
        }
 
        if (this->GetWidth() == nWidth && this->GetHeight() == nHeight)
        {
            // Nothing to do here
            RETURN_NOERROR;
        }
 
        RETURN_IF_POINTER_NULL(m_pBitmap);
 
        RETURN_IF_FAILED(Convert(nWidth, nHeight, m_sFormat.nBitsPerPixel));
 
        RETURN_NOERROR;
    }

    tResult ChangeDepth(tInt nBitsPerPixel, tInt nBytesPerLine = 0, tUInt32 ui32Mask = 0x0)
    {
        RETURN_IF_FAILED(Convert(m_sFormat.nWidth, m_sFormat.nHeight, nBitsPerPixel, nBytesPerLine, ui32Mask));
 
        RETURN_NOERROR;
    }

    tResult Convert(tInt nWidth, tInt nHeight, tInt nBitsPerPixel, tInt nBytesPerLine = 0, tUInt32 ui32Mask = 0x0)
    {
        tBitmapFormat sNewFormat;
        adtf::util::cMemoryBlock::MemSet(&sNewFormat, 0, sizeof(sNewFormat));
        sNewFormat.nWidth = nWidth;
        sNewFormat.nHeight = nHeight;
        sNewFormat.nBitsPerPixel = static_cast<int16_t>(nBitsPerPixel);
        sNewFormat.nBytesPerLine = nBytesPerLine;
        return Convert(&sNewFormat, ui32Mask);
    }

    tResult Convert(const tBitmapFormat* psFormat, tUInt32 ui32Mask = 0x0)
    {
        RETURN_IF_POINTER_NULL(psFormat);
        RETURN_IF_POINTER_NULL(m_pBitmap);
 
        tBitmapFormat sNewFormat = *psFormat;
 
        if (sNewFormat.nWidth == m_sFormat.nWidth && sNewFormat.nHeight == m_sFormat.nHeight &&
            sNewFormat.nBitsPerPixel == m_sFormat.nBitsPerPixel && sNewFormat.nPixelFormat == m_sFormat.nPixelFormat &&
            (sNewFormat.nBytesPerLine == 0 || sNewFormat.nBytesPerLine == m_sFormat.nBytesPerLine))
        {
            RETURN_NOERROR;
        }
 
        if (sNewFormat.nWidth <= 0 || sNewFormat.nHeight <= 0)
        {
            RETURN_ERROR(ERR_INVALID_ARG);
        }
 
        if (sNewFormat.nBytesPerLine == 0)
        {
            sNewFormat.nBytesPerLine =
                CalcAlignedMemSize((sNewFormat.nWidth * sNewFormat.nBitsPerPixel) / 8, m_nDefaultLineAlignment);
            sNewFormat.nSize = sNewFormat.nHeight * sNewFormat.nBytesPerLine;
        }
 
        cImage oTempImage;
        RETURN_IF_FAILED(oTempImage.Create(&sNewFormat));
        tResult nResult = ERR_NOERROR;
 
        if (sNewFormat.nPixelFormat == m_sFormat.nPixelFormat && ui32Mask == 0x0)
        {
            // just resize image
            nResult = StretchBlit(m_pBitmap, &m_sFormat, oTempImage.GetBitmap(), oTempImage.GetFormat());
        }
        else
        {
            // do bit conversions
            if (sNewFormat.nWidth == m_sFormat.nWidth && sNewFormat.nHeight == m_sFormat.nHeight)
            {
                nResult =
                    Convert_impl(m_pBitmap, &m_sFormat, oTempImage.GetBitmap(), oTempImage.GetFormat(), 0, ui32Mask);
            }
            else
            {
                nResult =
                    StretchBlit_impl(m_pBitmap, &m_sFormat, oTempImage.GetBitmap(), oTempImage.GetFormat(), ui32Mask);
            }
        }
 
        RETURN_IF_FAILED(nResult);
        if (GetSize() != oTempImage.GetSize())
        {
            Release();
            RETURN_IF_FAILED(Create(oTempImage.GetFormat()));
        }
        else
        {
            adtf::util::cMemoryBlock::MemCopy(&m_sFormat, oTempImage.GetFormat(), sizeof(m_sFormat));
        }
        adtf::util::cMemoryBlock::MemCopy(GetBitmap(), oTempImage.GetBitmap(), GetSize());
        RETURN_NOERROR;
    }

    tResult Convert(tInt oPixelFormat)
    {
        tBitmapFormat fmt = m_sFormat;
        fmt.nPixelFormat = tInt16(oPixelFormat);
        fmt.nBitsPerPixel = tInt16(CalcBitsPerPixelFromPixelFormat(oPixelFormat));
        fmt.nPaletteSize = 0;
        fmt.nBytesPerLine = 0;
        fmt.nSize = 0;
        return Convert(&fmt, 0U);
    }

    tResult ChangePixelFormat(tInt nFormat, tUInt32 ui32Flags = 0)
    {
        if ((m_sFormat.nPixelFormat == IImage::PF_8BIT) || (m_sFormat.nPixelFormat == IImage::PF_16BIT) ||
            (m_sFormat.nPixelFormat == IImage::PF_24BIT) || (m_sFormat.nPixelFormat == IImage::PF_32BIT))
        {
            auto const bpp = GetBitsPerPixel();
            auto const fmt = GetDefaultFormatFromBpp(bpp);
            m_sFormat.nPixelFormat = static_cast<int16_t>(fmt);
        }
 
        if (m_sFormat.nPixelFormat == IImage::PF_UNKNOWN)
        {
            LOG_ERROR("Got PF_UNKNOWN");
            RETURN_ERROR(ERR_UNKNOWN_FORMAT);
        }
 
        if (nFormat == m_sFormat.nPixelFormat)
        {
            RETURN_NOERROR;
        }
 
        auto nBpp = static_cast<int32_t>(CalcBitsPerPixelFromPixelFormat(nFormat));
        if (nBpp < 1)
        {
            RETURN_ERROR(ERR_NOT_SUPPORTED);
        }
 
        cImage oTempImage;
        oTempImage.Create(m_sFormat.nWidth, m_sFormat.nHeight, nBpp);
        oTempImage.SetPixelFormat(nFormat);
 
        if (IS_OK(
                Convert_impl(GetBitmap(), GetFormat(), oTempImage.GetBitmap(), oTempImage.GetFormat(), ui32Flags, 0x0)))
        {
            Create(m_sFormat.nWidth, m_sFormat.nHeight, nBpp);
            SetPixelFormat(nFormat);
            adtf::util::cMemoryBlock::MemCopy(GetBitmap(), oTempImage.GetBitmap(), oTempImage.GetSize());
            RETURN_NOERROR;
        }
 
        if (m_sFormat.nPixelFormat == PF_YUV420P_888 && m_sFormat.nBitsPerPixel == 24)
        {
            if (nFormat == PF_RGB_888)
            {
                m_sFormat.nBytesPerLine = CalcAlignedMemSize(m_sFormat.nWidth * 3, m_nDefaultLineAlignment);
                m_sFormat.nSize = m_sFormat.nBytesPerLine * m_sFormat.nHeight;
 
                tUInt8* pRGB;
                tHandle hRGBMem;
                RETURN_IF_FAILED(AllocImpl(m_sFormat.nSize, &hRGBMem, (tVoid**) &pRGB));
 
                tInt nYUPlaneSize = ((m_sFormat.nWidth + 1) / 2) * ((m_sFormat.nHeight + 1) / 2);
                tUInt8* pY = m_pBitmap;
                tUInt8* pV = pY + m_sFormat.nWidth * m_sFormat.nHeight;
                tUInt8* pU = pV + nYUPlaneSize;
                tInt nLineWidthUV = (m_sFormat.nWidth + 1) / 2;
                tInt nLineWidthRGB = m_sFormat.nBytesPerLine;
                tUInt8* pPixel = pRGB;
                for (tInt32 nY = 0; nY < m_sFormat.nHeight; ++nY)
                {
                    for (tInt32 nX = 0; nX < m_sFormat.nWidth; ++nX)
                    {
                        Yuv2Rgb(pY[nX], pU[nX / 2], pV[nX / 2], pPixel + nX * 3);
                    }
 
                    pPixel += nLineWidthRGB;
                    pY += m_sFormat.nWidth;
                    if (nY % 2)
                    {
                        pV += nLineWidthUV;
                        pU += nLineWidthUV;
                    }
                }
 
                if (m_hBitmapMemory != NULL)
                {
                    FreeImpl(m_hBitmapMemory);
                }
 
                m_hBitmapMemory = hRGBMem;
 
                m_bReference = tFalse;
                m_pBitmap = pRGB;
 
                m_sFormat.nPixelFormat = static_cast<int16_t>(nFormat);
 
                RETURN_NOERROR;
            }
        }
 
        if (m_sFormat.nPixelFormat == PF_RGB_888 && m_sFormat.nBitsPerPixel == 24)
        {
            if (nFormat == PF_YUV420P_888)
            {
                tInt nYUPlaneSize = ((m_sFormat.nWidth + 1) / 2) * ((m_sFormat.nHeight + 1) / 2);
 
                m_sFormat.nSize = m_sFormat.nWidth * m_sFormat.nHeight + 2 * nYUPlaneSize;
 
                tUInt8* pYUV;
                tHandle hYUVMem;
                RETURN_IF_FAILED(AllocImpl(m_sFormat.nSize, &hYUVMem, (tVoid**) &pYUV));
 
                tInt nLineWidthRGB = m_sFormat.nBytesPerLine;
                tUInt8* pY = pYUV;
                tUInt8* pRGBLine = m_pBitmap;
                for (tInt32 nY = 0; nY < m_sFormat.nHeight; ++nY)
                {
                    for (tInt32 nX = 0; nX < m_sFormat.nWidth; ++nX)
                    {
                        pY[nX] = YFromRGB(pRGBLine + nX * 3);
                    }
                    pRGBLine += nLineWidthRGB;
                    pY += m_sFormat.nWidth;
                }
 
                pRGBLine = m_pBitmap;
                tUInt8* pV = pY;
                tUInt8* pU = pV + nYUPlaneSize;
                tInt nLineWidth = (m_sFormat.nWidth + 1) / 2;
                nLineWidthRGB += nLineWidthRGB;
                for (tInt32 nY = 0; nY < m_sFormat.nHeight; nY += 2)
                {
                    for (tInt32 nX = 0; nX < m_sFormat.nWidth; nX += 2)
                    {
                        tUInt8* pPixel = pRGBLine + nX * 3;
                        pU[nX / 2] = UFromRGB(pPixel);
                        pV[nX / 2] = VFromRGB(pPixel);
                    }
                    pRGBLine += nLineWidthRGB;
                    pU += nLineWidth;
                    pV += nLineWidth;
                }
 
                if (m_hBitmapMemory != NULL)
                {
                    FreeImpl(m_hBitmapMemory);
                }
 
                m_hBitmapMemory = hYUVMem;
                m_bReference = tFalse;
                m_pBitmap = pYUV;
                m_sFormat.nPixelFormat = static_cast<int16_t>(nFormat);
 
                RETURN_NOERROR;
            }
        }
 
        RETURN_ERROR(ERR_NOT_SUPPORTED);
    }

    tResult FlipRGB()
    {
        RETURN_IF_POINTER_NULL(m_pBitmap);
        tBitmapFormat sFormat = m_sFormat;
 
        switch (m_sFormat.nPixelFormat)
        {
            case PF_RGB_888: sFormat.nPixelFormat = PF_BGR_888; break;
            case PF_BGR_888: sFormat.nPixelFormat = PF_RGB_888; break;
            case PF_ABGR_8888: sFormat.nPixelFormat = PF_ARGB_8888; break;
            case PF_ARGB_8888: sFormat.nPixelFormat = PF_ABGR_8888; break;
            case PF_BGRA_8888: sFormat.nPixelFormat = PF_RGBA_8888; break;
            case PF_RGBA_8888: sFormat.nPixelFormat = PF_BGRA_8888; break;
            default: RETURN_NOERROR;
        }
 
        return Convert(&sFormat);
    }

    tResult FlipAlpha()
    {
        if (0 == GetBytesPerLine())
        {
            RETURN_ERROR(ERR_UNEXPECTED);
        }
 
        tBool bAlphaFromHighToLow = tFalse;
 
        switch (m_sFormat.nPixelFormat)
        {
            case PF_ABGR_8888:
            {
                m_sFormat.nPixelFormat = PF_BGRA_8888;
                bAlphaFromHighToLow = tTrue;
            }
            break;
            case PF_ARGB_8888:
            {
                m_sFormat.nPixelFormat = PF_RGBA_8888;
                bAlphaFromHighToLow = tTrue;
            }
            break;
            case PF_BGRA_8888:
            {
                m_sFormat.nPixelFormat = PF_ABGR_8888;
                bAlphaFromHighToLow = tFalse;
            }
            break;
            case PF_RGBA_8888:
            {
                m_sFormat.nPixelFormat = PF_ARGB_8888;
                bAlphaFromHighToLow = tFalse;
            }
            break;
            default: RETURN_ERROR(ERR_NOT_SUPPORTED);
        }
 
        tUInt32* pLine = (tUInt32*) GetBitmap();
 
        if (bAlphaFromHighToLow)
        {
            // ARGB => RGBA, ABGR => BGRA
            for (tInt nLine = 0; nLine < m_sFormat.nHeight; nLine++)
            {
                for (tInt nPos = 0; nPos < m_sFormat.nWidth; nPos++)
                {
                    pLine[nPos] = (pLine[nPos] >> 24) | (pLine[nPos] << 8);
                }
                pLine += GetBytesPerLine() / 4;
            }
        }
        else
        {
            // RGBA => ARGB, BGRA => ABGR
            for (tInt nLine = 0; nLine < m_sFormat.nHeight; nLine++)
            {
                for (tInt nPos = 0; nPos < m_sFormat.nWidth; nPos++)
                {
                    pLine[nPos] = (pLine[nPos] << 24) | (pLine[nPos] >> 8);
                }
                pLine += GetBytesPerLine() / 4;
            }
        }
        RETURN_NOERROR;
    }

    tResult MakeAlphaChannel(const tColor& sColorKey, tBool bClearTransparent = tFalse)
    {
        tInt nOrgPixelFormat = GetPixelFormat();
        if (nOrgPixelFormat != PF_RGBA_8888)
        {
            RETURN_IF_FAILED(ChangePixelFormat(PF_RGBA_8888));
        }
 
        tUInt8* pBitmap = GetBitmap();
        RETURN_IF_POINTER_NULL(pBitmap);
 
        tUInt8* pLine = pBitmap;
        tUInt32* ptr;
        tUInt8* pPixelAlpha;
 
        tInt nHeight = GetHeight();
        tInt nBytesPerLine = GetBytesPerLine();
        tInt nSteps = nBytesPerLine / 4;
 
        tUInt32 ui32CompValue = (tUInt32) sColorKey.nBlue | ((tUInt32) sColorKey.nGreen << 8) |
                                ((tUInt32) sColorKey.nRed << 16) | ((tUInt32) sColorKey.nAlpha << 24);
        ui32CompValue = ui32CompValue & 0x00FFFFFF; // removing the alphavalue
 
        for (tInt nLine = 0; nLine < nHeight; nLine++)
        {
            ptr = (tUInt32*) pLine;
            pPixelAlpha = pLine + 3;
 
            for (tInt nStep = 0; nStep < nSteps; nStep++)
            {
                if ((*ptr & 0x00FFFFFF) == ui32CompValue)
                {
                    *pPixelAlpha = 0;
                    if (bClearTransparent)
                    {
                        *ptr = 0;
                    }
                }
                else
                {
                    *pPixelAlpha = 0xFF;
                }
 
                ptr++;
                pPixelAlpha += 4;
            }
 
            pLine += nBytesPerLine;
        }
 
        RETURN_NOERROR;
    }
 
public: // blit functions
    tResult Blit(const cImage& oDestImage, tInt nFlags = 0)
    {
        return Blit(GetBitmap(), GetFormat(), oDestImage.GetBitmap(), oDestImage.GetFormat(), nFlags);
    }

    tResult SetBits(const tUInt8* pSrcBitmapData, const tBitmapFormat* psSrcBitmapFormat)
    {
        RETURN_IF_POINTER_NULL(pSrcBitmapData);
        RETURN_IF_POINTER_NULL(psSrcBitmapFormat);
        const tBitmapFormat* m_pMyFormat = GetFormat();
        if (0 != adtf::util::cMemoryBlock::MemCmp(psSrcBitmapFormat, m_pMyFormat, sizeof(*pSrcBitmapData)) ||
            m_pBitmap == NULL)
        {
            RETURN_IF_FAILED(Release());
            RETURN_IF_FAILED(Create(psSrcBitmapFormat));
        }
 
        adtf::util::cMemoryBlock::MemCopy(m_pBitmap, pSrcBitmapData, GetSize());
        RETURN_NOERROR;
    }

    tResult GetBits(tUInt8* pDestBitmapData, const tBitmapFormat* psDestBitmapFormat, tInt nFlags = 0)
    {
        return Blit(GetBitmap(), GetFormat(), pDestBitmapData, psDestBitmapFormat, nFlags);
    }
 
public: // static blit functions
    static tResult Blit(const disptb::graphicslib::dengar::cImage& oSrcImage,
                        const disptb::graphicslib::dengar::cImage& oDestImage,
                        tInt nFlags = 0)
    {
        return Blit(oSrcImage.GetBitmap(), oSrcImage.GetFormat(), oDestImage.GetBitmap(), oDestImage.GetFormat(),
                    nFlags);
    }

    static tResult Blit(const tUInt8* pSrcBitmapData,
                        const tBitmapFormat* psSrcBitmapFormat,
                        tUInt8* pDestBitmapData,
                        const tBitmapFormat* psDestBitmapFormat,
                        tInt nFlags = 0)
    {
        return Blit_impl(pSrcBitmapData, psSrcBitmapFormat, pDestBitmapData, psDestBitmapFormat, nFlags);
    }

    static tResult StretchBlit(const disptb::graphicslib::dengar::cImage& oSrcImage,
                               const disptb::graphicslib::dengar::cImage& oDestImage,
                               tInt nFlags = 0)
    {
        return StretchBlit(oSrcImage.GetBitmap(), oSrcImage.GetFormat(), oDestImage.GetBitmap(), oDestImage.GetFormat(),
                           nFlags);
    }

    static tResult StretchBlit(const tUInt8* pSrcBitmapData,
                               const tBitmapFormat* psSrcBitmapFormat,
                               tUInt8* pDestBitmapData,
                               const tBitmapFormat* psDestBitmapFormat,
                               tInt nFlags = 0)
    {
        return StretchBlit_impl(pSrcBitmapData, psSrcBitmapFormat, pDestBitmapData, psDestBitmapFormat, nFlags);
    }

    static tResult Convert(const tUInt8* pSrcBitmapData,
                           const tBitmapFormat* psSrcBitmapFormat,
                           tUInt8* pDestBitmapData,
                           const tBitmapFormat* psDestBitmapFormat,
                           tInt nFlags,
                           tUInt32 ui32Mask)
    {
        RETURN_IF_POINTER_NULL(pSrcBitmapData);
        RETURN_IF_POINTER_NULL(psSrcBitmapFormat);
        RETURN_IF_POINTER_NULL(pDestBitmapData);
        RETURN_IF_POINTER_NULL(psDestBitmapFormat);
        if (psSrcBitmapFormat->nWidth != psDestBitmapFormat->nWidth ||
            psSrcBitmapFormat->nHeight != psDestBitmapFormat->nHeight)
        {
            return StretchBlit_impl(pSrcBitmapData, psSrcBitmapFormat, pDestBitmapData, psDestBitmapFormat, nFlags,
                                    ui32Mask);
        }
        else
        {
            return Convert_impl(pSrcBitmapData, psSrcBitmapFormat, pDestBitmapData, psDestBitmapFormat, nFlags,
                                ui32Mask);
        }
    }

    static tResult AlphaBlend(disptb::graphicslib::dengar::cImage* pSourceImage,
                              disptb::graphicslib::dengar::cImage* pDestImage,
                              disptb::graphicslib::dengar::cImage* pMaskImage)
    {
        RETURN_IF_POINTER_NULL(pSourceImage);
        RETURN_IF_POINTER_NULL(pDestImage);
        RETURN_IF_POINTER_NULL(pMaskImage);
        RETURN_IF_POINTER_NULL(pSourceImage->GetBitmap());
        RETURN_IF_POINTER_NULL(pDestImage->GetBitmap());
        RETURN_IF_POINTER_NULL(pMaskImage->GetBitmap());
 
        if ((pMaskImage->GetWidth() < pSourceImage->GetWidth()) ||
            (pMaskImage->GetHeight() < pSourceImage->GetHeight()) ||
            (pDestImage->GetHeight() < pSourceImage->GetHeight()) ||
            (pDestImage->GetWidth() < pSourceImage->GetWidth()))
        {
            RETURN_ERROR(ERR_UNEXPECTED);
        }
        if ((PF_RGB_888 != pSourceImage->GetPixelFormat()) && (PF_BGR_888 != pSourceImage->GetPixelFormat()) &&
            (PF_BGRA_8888 != pSourceImage->GetPixelFormat()) && (PF_RGBA_8888 != pSourceImage->GetPixelFormat()))
        {
            RETURN_ERROR(ERR_NOT_SUPPORTED);
        }
 
        if ((PF_RGB_888 != pDestImage->GetPixelFormat()) && (PF_BGR_888 != pDestImage->GetPixelFormat()) &&
            (PF_BGRA_8888 != pDestImage->GetPixelFormat()) && (PF_RGBA_8888 != pDestImage->GetPixelFormat()))
        {
            RETURN_ERROR(ERR_NOT_SUPPORTED);
        }
 
        tUInt8* pSourceBuffer = pSourceImage->GetBitmap();
        tUInt8* pDestBuffer = pDestImage->GetBitmap();
        tUInt8* pMaskBuffer = pMaskImage->GetBitmap();
 
        tUInt8* pSrcLine = pSourceBuffer;
        tUInt8* pDestLine = pDestBuffer;
        tUInt8* pMaskLine = pMaskBuffer;
 
        tUInt8* pSrc;
        tUInt8* pDest;
        tUInt8* pMask;
 
        tInt nHeight = pSourceImage->GetHeight();
        tInt nWidth = pSourceImage->GetWidth();
        tInt nAlpha;
 
        for (tInt y = 0; y < nHeight; y++)
        {
            pSrc = pSrcLine;
            pDest = pDestLine;
            pMask = pMaskLine;
 
            for (tInt x = 0; x < nWidth; x++)
            {
                nAlpha = *(pMask++);
                *(pDest) = (tUInt8) (((*pDest * nAlpha) + (*pSrc * (255 - nAlpha))) / 255);
                pSrc++;
                pDest++;
                *(pDest) = (tUInt8) (((*pDest * nAlpha) + (*pSrc * (255 - nAlpha))) / 255);
                pSrc++;
                pDest++;
                *(pDest) = (tUInt8) (((*pDest * nAlpha) + (*pSrc * (255 - nAlpha))) / 255);
                pSrc++;
                pDest++;
            }
 
            pSrcLine += pSourceImage->GetBytesPerLine();
            pDestLine += pDestImage->GetBytesPerLine();
            pMaskLine += pMaskImage->GetBytesPerLine();
        }
 
        RETURN_NOERROR;
    }

    static tResult BilinearStretchBlit(disptb::graphicslib::dengar::cImage& oSrc,
                                       disptb::graphicslib::dengar::cImage& oDest)
    {
        if (oSrc.GetPixelFormat() != oDest.GetPixelFormat())
        {
            RETURN_ERROR(ERR_NOT_IMPL);
        }
 
        if ((PF_RGB_888 != oSrc.GetPixelFormat()) && (PF_RGBA_8888 != oSrc.GetPixelFormat()))
        {
            RETURN_ERROR(ERR_NOT_SUPPORTED);
        }
        tUInt8* pSrcBitmapData = oSrc.GetBitmap();
        tUInt8* pDestBitmapData = oDest.GetBitmap();
 
        RETURN_IF_POINTER_NULL(pSrcBitmapData);
        RETURN_IF_POINTER_NULL(pDestBitmapData);
 
        const tBitmapFormat* psSrcBitmapFormat = oSrc.GetFormat();
        const tBitmapFormat* psDestBitmapFormat = oDest.GetFormat();
 
        RETURN_IF_POINTER_NULL(psSrcBitmapFormat);
        RETURN_IF_POINTER_NULL(psDestBitmapFormat);
 
        tInt l_nCopyWidth = psDestBitmapFormat->nWidth;
        tInt l_nCopyHeight = psDestBitmapFormat->nHeight;
 
        const tUInt8* l_pSrcLine = pSrcBitmapData;
        const tUInt8* l_pSrcLine2 = pSrcBitmapData;
 
        tUInt8* l_pDestLine = pDestBitmapData;
        tInt l_nBytesPerPixel = psSrcBitmapFormat->nBitsPerPixel / 8;
 
        tInt nCopySrcStep = psSrcBitmapFormat->nWidth;
        tInt nCopySrcMax = l_nCopyWidth * nCopySrcStep;
 
        tInt y2, y3;
        tInt y_weight;
 
        for (tInt y = 0; y < l_nCopyHeight; y++)
        {
            y_weight = GET_REMAINDER(y, psSrcBitmapFormat->nHeight, psDestBitmapFormat->nHeight, 256);
 
            y2 = (y * psSrcBitmapFormat->nHeight) / l_nCopyHeight;
            y3 = y2 + 1;
            if (y3 >= psSrcBitmapFormat->nHeight)
                y3 = y2;
 
            l_pSrcLine = pSrcBitmapData + y2 * psSrcBitmapFormat->nBytesPerLine;
            l_pSrcLine2 = pSrcBitmapData + y3 * psSrcBitmapFormat->nBytesPerLine;
 
            l_pDestLine = pDestBitmapData + y * psDestBitmapFormat->nBytesPerLine;
 
            if (l_nBytesPerPixel == 4)
            {
                tUInt32* l_pui32SrcLine = (tUInt32*) l_pSrcLine;
                tUInt32* l_pui32SrcLine2 = (tUInt32*) l_pSrcLine2;
                tUInt32* l_pui32DestLine = (tUInt32*) l_pDestLine;
 
                tUInt32 v, v1, v2, v3, v4;
                tInt x2;
                tInt x_weight;
                for (tInt x = 0; x < nCopySrcMax; x += nCopySrcStep)
                {
                    x_weight =
                        GET_REMAINDER(x / nCopySrcStep, psSrcBitmapFormat->nWidth, psDestBitmapFormat->nWidth, 256);
 
                    x2 = x + nCopySrcStep;
                    if (x2 >= nCopySrcMax)
                        x2 = x;
 
                    v1 = *(l_pui32SrcLine + x / l_nCopyWidth);
                    v2 = *(l_pui32SrcLine2 + x / l_nCopyWidth);
                    v3 = *(l_pui32SrcLine + x2 / l_nCopyWidth);
                    v4 = *(l_pui32SrcLine2 + x2 / l_nCopyWidth);
 
                    v = BlendRGB32(v1, v2, v3, v4, y_weight, x_weight);
 
                    *(l_pui32DestLine++) = v;
                }
            }
            else if (l_nBytesPerPixel == 3)
            {
                tUInt8* l_pui8SrcLine = (tUInt8*) l_pSrcLine;
                tUInt8* l_pui8SrcLine2 = (tUInt8*) l_pSrcLine2;
                tUInt8* l_pui8DestLine = (tUInt8*) l_pDestLine;
 
                tUInt8 v, v1, v2, v3, v4;
                tInt x2;
                tInt x_weight;
                for (tInt x = 0; x < nCopySrcMax; x += nCopySrcStep)
                {
                    x_weight =
                        GET_REMAINDER(x / nCopySrcStep, psSrcBitmapFormat->nWidth, psDestBitmapFormat->nWidth, 256);
 
                    x2 = x + nCopySrcStep;
                    if (x2 >= nCopySrcMax)
                        x2 = x;
 
                    v1 = *(l_pui8SrcLine + (x / l_nCopyWidth) * 3);
                    v2 = *(l_pui8SrcLine2 + (x / l_nCopyWidth) * 3);
                    v3 = *(l_pui8SrcLine + (x2 / l_nCopyWidth) * 3);
                    v4 = *(l_pui8SrcLine2 + (x2 / l_nCopyWidth) * 3);
                    v = BlendPixel(v1, v2, v3, v4, y_weight, x_weight);
 
                    *(l_pui8DestLine++) = v;
 
                    v1 = *(l_pui8SrcLine + (x / l_nCopyWidth) * 3 + 1);
                    v2 = *(l_pui8SrcLine2 + (x / l_nCopyWidth) * 3 + 1);
                    v3 = *(l_pui8SrcLine + (x2 / l_nCopyWidth) * 3 + 1);
                    v4 = *(l_pui8SrcLine2 + (x2 / l_nCopyWidth) * 3 + 1);
                    v = BlendPixel(v1, v2, v3, v4, y_weight, x_weight);
 
                    *(l_pui8DestLine++) = v;
 
                    v1 = *(l_pui8SrcLine + (x / l_nCopyWidth) * 3 + 2);
                    v2 = *(l_pui8SrcLine2 + (x / l_nCopyWidth) * 3 + 2);
                    v3 = *(l_pui8SrcLine + (x2 / l_nCopyWidth) * 3 + 2);
                    v4 = *(l_pui8SrcLine2 + (x2 / l_nCopyWidth) * 3 + 2);
                    v = BlendPixel(v1, v2, v3, v4, y_weight, x_weight);
 
                    *(l_pui8DestLine++) = v;
                }
            }
        }
 
        RETURN_NOERROR;
    }

    static tResult SetTransparency(disptb::graphicslib::dengar::cImage* pImage,
                                   disptb::graphicslib::dengar::cColor oColor)
    {
        RETURN_IF_POINTER_NULL(pImage);
        RETURN_IF_POINTER_NULL(pImage->GetBitmap());
        RETURN_IF_POINTER_NULL(pImage->GetBitmapInfo());
 
        switch (pImage->GetPixelFormat())
        {
            case IImage::PF_RGBA_8888:
            case IImage::PF_BGRA_8888: break;
            default:
            {
                tBitmapFormat oFormat = *pImage->GetFormat();
                oFormat.nBitsPerPixel = 32;
                oFormat.nPixelFormat = IImage::PF_RGBA_8888;
                oFormat.nBytesPerLine = 0;
                RETURN_IF_FAILED(pImage->Convert(&oFormat));
                break;
            }
        }
 
        auto pPixel = (tUInt32*) pImage->GetBitmap();
        tUInt32 nTranspColor = oColor.GetRGBA(pImage->GetPixelFormat()) & 0x00ffffff;
        tInt nWidth = pImage->GetWidth();
        tInt nHeight = pImage->GetHeight();
        tInt nBPL = pImage->GetBytesPerLine();
 
        for (tInt nY = 0; nY < nHeight; nY++)
        {
            for (tInt nX = 0; nX < nWidth; nX++)
            {
                if ((pPixel[nX] & 0x00ffffff) == nTranspColor)
                {
                    pPixel[nX] = 0x00000000;
                }
                else
                {
                    pPixel[nX] = pPixel[nX] | 0xff000000;
                }
            }
            pPixel += nBPL / 4;
        }
        RETURN_NOERROR;
    }
 
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)
    {
        Release();
 
        HRSRC hResource = ::FindResource((HMODULE) hModule, MAKEINTRESOURCE(nResourceId), RT_BITMAP);
        if (NULL == hResource)
        {
            RETURN_ERROR(ERR_NOT_FOUND);
        }
 
        HGLOBAL hResourceData = ::LoadResource((HMODULE) hModule, hResource);
        if (NULL == hResourceData)
        {
            RETURN_ERROR(ERR_NOACCESS);
        }
 
        BITMAPINFOHEADER* pBitmap = (BITMAPINFOHEADER*) ::LockResource(hResourceData);
        if (NULL == pBitmap)
        {
            ::FreeResource(hResourceData);
            RETURN_ERROR(ERR_NOACCESS);
        }
 
        tVoid* pPalette;
        tInt nPaletteSize;
        if (pBitmap->biBitCount <= 8)
        {
            BITMAPINFO* pBitmapHeader = (BITMAPINFO*) pBitmap;
 
            nPaletteSize = (1 << pBitmap->biBitCount);
            pPalette = (tVoid*) &pBitmapHeader->bmiColors[0];
        }
        else
        {
            nPaletteSize = 0;
            pPalette = NULL;
        }
 
        tUInt8* pBitmapData = (tUInt8*) pBitmap + pBitmap->biSize + nPaletteSize * sizeof(tUInt32);
 
        tResult nResult = Create(pBitmap->biWidth, pBitmap->biHeight, pBitmap->biBitCount, 0, pBitmapData);
        if (IS_OK(nResult) && NULL != pPalette)
        {
            nResult = SetPalette(nPaletteSize, (tColor*) pPalette);
        }
 
        UnlockResource(hResourceData);
        ::FreeResource(hResourceData);
 
        if (IS_FAILED(nResult))
        {
            return nResult;
        }
 
        // windows bitmaps are always BGR
        if (m_sFormat.nBitsPerPixel == 24)
        {
            SetPixelFormat(cImage::PF_RGB_888);
        }
        else if (m_sFormat.nBitsPerPixel == 32)
        {
            SetPixelFormat(cImage::PF_RGBA_8888);
        }
 
        if (m_sFormat.nBitsPerPixel >= 24 && ((nFlags & LF_SWAP_RGB) != 0))
        {
            FlipRGB();
        }
 
        if (((nFlags & LF_FLIP_VERTICAL) == 0))
        {
            Flip();
        }
 
        RETURN_NOERROR;
    }
    tResult CaptureScreen(tInt x, tInt y, tInt nWidth, tInt nHeight)
    {
        RETURN_IF_FAILED(Create(nWidth, nHeight, 24));
        if ((nWidth < 1) || (nHeight < 1) || (x < 0) || (y < 0))
        {
            RETURN_ERROR(ERR_INVALID_ARG);
        }
        HDC hdcScreen = ::GetDC(NULL);
        HDC hdcCapture = ::CreateCompatibleDC(hdcScreen);
        HBITMAP bmCapture = ::CreateCompatibleBitmap(hdcScreen, nWidth, nHeight);
 
        ::SetStretchBltMode(hdcCapture, COLORONCOLOR);
        ::SelectObject(hdcCapture, bmCapture);
 
        ::StretchBlt(hdcCapture, 0, 0, nWidth, nHeight, hdcScreen, x, y, nWidth, nHeight, SRCCOPY);
 
        ::GetDIBits(hdcCapture, bmCapture, 0, nHeight, GetBitmap(), (BITMAPINFO*) GetBitmapInfo(), DIB_RGB_COLORS);
 
        ::DeleteObject(bmCapture);
        ::DeleteDC(hdcCapture);
 
        ::ReleaseDC(NULL, hdcScreen);
 
        RETURN_NOERROR;
    }
    tHandle CreateRegion()
    {
        switch (GetPixelFormat())
        {
            case PF_8BIT:
            case PF_RGB_8:
            case PF_GREYSCALE_8:
            case PF_RGB_888:
            case PF_RGBA_8888: break;
            default: return NULL;
        }
 
        HRGN hRgn = ::CreateRectRgn(0, 0, GetWidth(), GetHeight());
 
        tBool bVFlip = tTrue;
        tInt nBytesPerLine = GetBytesPerLine();
        tInt nBytesPerPixel = GetBitsPerPixel() / 8;
 
        tUInt8* pImage = GetBitmap();
        tUInt8* pLine = pImage;
        if (bVFlip)
        {
            pLine += nBytesPerLine * (GetHeight() - 1);
        }
 
        tUInt8* ptr;
        tUInt8 r, g, b = 0;
 
        tInt rgn_start = -1;
        tBool bTransparent;
 
        for (tInt y = 0; y < GetHeight(); y++)
        {
            ptr = pLine;
            for (tInt x = 0; x < GetWidth(); x++)
            {
                bTransparent = tFalse;
 
                if (nBytesPerPixel >= 3)
                {
                    r = *(ptr);
                    g = *(ptr + 1);
                    b = *(ptr + 2);
 
                    if (r == 0xFF && g == 0x00 && b == 0xFF)
                    {
                        bTransparent = tTrue;
                    }
                }
                else // 8 bit
                {
                    if (*ptr == 0x00)
                    {
                        bTransparent = tTrue;
                    }
                }
 
                if (bTransparent)
                {
                    if (rgn_start < 0)
                    {
                        rgn_start = x;
                    }
                }
                else
                {
                    if (rgn_start >= 0)
                    {
                        HRGN hLocalRgn = ::CreateRectRgn(rgn_start, y, x, y + 1);
                        ::CombineRgn(hRgn, hRgn, hLocalRgn, RGN_DIFF);
                        ::DeleteObject(hLocalRgn);
 
                        rgn_start = -1;
                    }
                }
 
                ptr += nBytesPerPixel;
            }
 
            if (rgn_start >= 0)
            {
                HRGN hLocalRgn = ::CreateRectRgn(rgn_start, y, GetWidth(), y + 1);
                ::CombineRgn(hRgn, hRgn, hLocalRgn, RGN_DIFF);
                ::DeleteObject(hLocalRgn);
 
                rgn_start = -1;
            }
 
            if (bVFlip)
            {
                pLine -= nBytesPerLine;
            }
            else
            {
                pLine += nBytesPerLine;
            }
        }
 
        return (tHandle) hRgn;
    }
#endif // WIN32

    tBool Compare(const disptb::graphicslib::dengar::cImage& oImage)
    {
        if (this == &oImage)
        {
            return tTrue;
        }
 
        if ((oImage.m_sFormat.nWidth != m_sFormat.nWidth) || (oImage.m_sFormat.nHeight != m_sFormat.nHeight) ||
            (oImage.m_sFormat.nPixelFormat != m_sFormat.nPixelFormat) ||
            (oImage.m_sFormat.nBitsPerPixel != m_sFormat.nBitsPerPixel))
        {
            return tFalse;
        }
 
        if (oImage.GetBitmap() == GetBitmap())
        {
            return tTrue;
        }
 
        tInt nBytesToCompare = m_sFormat.nWidth * m_sFormat.nBitsPerPixel / 8;
 
        for (tInt nLine = 0; nLine < m_sFormat.nHeight; nLine++)
        {
            tInt nOffset = nLine * m_sFormat.nBytesPerLine;
            if (adtf::util::cMemoryBlock::MemCmp(GetBitmap() + nOffset, oImage.GetBitmap() + nOffset,
                                                 nBytesToCompare) != 0)
            {
                return tFalse;
            }
        }
 
        return tTrue;
    }

    tInt CountDifferences(const disptb::graphicslib::dengar::cImage& oImage)
    {
        if (this == &oImage)
        {
            return 0;
        }
 
        if ((oImage.m_sFormat.nWidth != m_sFormat.nWidth) || (oImage.m_sFormat.nHeight != m_sFormat.nHeight) ||
            (oImage.m_sFormat.nPixelFormat != m_sFormat.nPixelFormat) ||
            (oImage.m_sFormat.nBitsPerPixel != m_sFormat.nBitsPerPixel))
        {
            return -1;
        }
 
        if (oImage.GetBitmap() == GetBitmap())
        {
            return 0;
        }
 
        tInt nResult = 0;
        tInt nBytesPerPixel = m_sFormat.nBitsPerPixel / 8;
        tInt nBytesToCompare = m_sFormat.nWidth * nBytesPerPixel;
 
        for (tInt nLine = 0; nLine < m_sFormat.nHeight; nLine++)
        {
            tInt nOffset = nLine * m_sFormat.nBytesPerLine;
 
            tUInt8* pLine = GetBitmap() + nOffset;
            tUInt8* pRefLine = oImage.GetBitmap() + nOffset;
 
            for (tInt i = 0; i < nBytesToCompare; i += nBytesPerPixel)
            {
                for (tInt p = 0; p < nBytesPerPixel; p++)
                {
                    if (pLine[i + p] != pRefLine[i + p])
                    {
                        nResult++;
                        break;
                    }
                }
            }
        }
 
        return nResult;
    }

    static tInt CalcAlignedMemSize(tInt nBytes, tInt nAlignment)
    {
        if (nBytes < 0)
        {
            return 0;
        }
 
        if (nAlignment < 1)
        {
            return nBytes;
        }
 
        if (nBytes % nAlignment)
        {
            return (nBytes + (nAlignment - (nBytes % nAlignment)));
        }
 
        return nBytes;
    }

    static tInt GuessPixelFormat(const tBitmapFormat* pFormat)
    {
        if (pFormat->nPixelFormat != cImage::PF_UNKNOWN)
        {
            // nothing to guess
            return pFormat->nPixelFormat;
        }
 
        tUInt nExpectedSize = (pFormat->nBitsPerPixel / 8) * pFormat->nWidth * pFormat->nHeight;
        if (nExpectedSize > static_cast<tUInt>(pFormat->nSize))
        {
            // Size does not match our default formats
            return cImage::PF_UNKNOWN;
        }
 
        switch (pFormat->nBitsPerPixel)
        {
            case 8: return cImage::PF_GREYSCALE_8;
            case 16: return cImage::PF_RGB_555;
            case 24: return cImage::PF_RGB_888;
            case 32: return cImage::PF_RGBA_8888;
            default: return cImage::PF_UNKNOWN;
        }
    }

    static tInt GetBitsPerPixelFromFormat(tInt nFormat)
    {
        return CalcBitsPerPixelFromPixelFormat(nFormat);
    }

    static tInt GetDefaultFormatFromBpp(tInt nBpp)
    {
        switch (nBpp)
        {
            case 32: return PF_RGBA_8888;
            case 24: return PF_RGB_888;
            case 16: return PF_RGB_555;
            case 8: return PF_GREYSCALE_8;
            default: return PF_UNKNOWN;
        }
    }

    static tChar const* GetPixelFormatIdentifier(const tInt nImage)
    {
        switch (nImage)
        {
            case PF_UNKNOWN:
            {
                return "UNKNOWN";
            }
            case PF_8BIT:
            {
                return "8 bit";
            }
            case PF_GREYSCALE_8:
            {
                return "8 bit greyscale";
            }
            case PF_RGB_8:
            {
                return "8 bit RGB";
            }
            case PF_16BIT:
            {
                return "16 bit";
            }
            case PF_GREYSCALE_10:
            {
                return "10 bit greyscale";
            }
            case PF_GREYSCALE_12:
            {
                return "12 bit greyscale";
            }
            case PF_GREYSCALE_14:
            {
                return "14 bit greyscale";
            }
            case PF_GREYSCALE_16:
            {
                return "16 bit greyscale";
            }
            case PF_RGB_444:
            {
                return "12 bit RGB";
            }
            case PF_RGB_555:
            {
                return "15 bit RGB";
            }
            case PF_RGB_565:
            {
                return "16 bit RGB";
            }
            case PF_RGBA_4444:
            {
                return "16 bit RGBA";
            }
            case PF_ABGR_4444:
            {
                return "16 bit ABGR";
            }
            case PF_RIII_10:
            {
                return "10 bit RIII";
            }
            case PF_RIII_12:
            {
                return "12 bit RIII";
            }
            case PF_RIII_14:
            {
                return "14 bit RIII";
            }
            case PF_RIII_16:
            {
                return "16 bit RIII";
            }
            case PF_BGR_555:
            {
                return "15 bit BGR";
            }
            case PF_BGR_565:
            {
                return "16 bit BGR";
            }
            case PF_RGBA_5551:
            {
                return "16 bit RGBA 5551";
            }
            case PF_BGRA_5551:
            {
                return "16 bit BGRA 5551";
            }
            case PF_ARGB_1555:
            {
                return "16 bit ARGB 1555";
            }
            case PF_ABGR_1555:
            {
                return "16 bit ABGR 1555";
            }
            case PF_24BIT:
            {
                return "24 bit";
            }
            case PF_GREYSCALE_18:
            {
                return "18 bit greyscale";
            }
            case PF_GREYSCALE_20:
            {
                return "20 bit greyscale";
            }
            case PF_GREYSCALE_22:
            {
                return "22 bit greyscale";
            }
            case PF_GREYSCALE_24:
            {
                return "24 bit greyscale";
            }
            case PF_RGB_888:
            {
                return "24 bit RGB";
            }
            case PF_BGR_888:
            {
                return "24 bit BGR";
            }
            case PF_32BIT:
            {
                return "32 bit";
            }
            case PF_ARGB_8888:
            {
                return "32 bit ARGB";
            }
            case PF_ABGR_8888:
            {
                return "32 bit ABGR";
            }
            case PF_RGBA_8888:
            {
                return "32 bit RGBA";
            }
            case PF_BGRA_8888:
            {
                return "32 bit BGRA";
            }
            case PF_xRGB_8888:
            {
                return "32 bit xRGB";
            }
            case PF_xBGR_8888:
            {
                return "32 bit xBGR";
            }
            case PF_RGBx_8888:
            {
                return "32 bit RGBx";
            }
            case PF_BGRx_8888:
            {
                return "32 bit BGRx";
            }
            case PF_GREYSCALE_32:
            {
                return "32bit greyscale";
            }
            case PF_GREYSCALE_FLOAT32:
            {
                return "32 bit float greyscale";
            }
            case PF_YUV420P_888:
            {
                return "24 bit YUV420P";
            }
            case PF_CUSTOM:
            {
                return "CUSTOM";
            }
            default:
            {
                return "NOT DEFINED";
            }
        }
    }
 
protected: // internal
    tResult Initialize()
    {
        adtf::util::cMemoryBlock::MemSet(&m_sFormat, 0, sizeof(m_sFormat));
 
        m_bReference = tFalse;
        m_pBitmap = NULL;
        m_hBitmapMemory = NULL;
        m_pPalette = NULL;
        m_psBitmapInfo = NULL;
        m_nBitmapInfoSize = 0;
        m_nGreyPaletteSize = 0;
 
        RETURN_NOERROR;
    }

    tResult Alloc(const tBitmapFormat* psFormat)
    {
        if (m_bReference)
        {
            m_pBitmap = NULL;
            m_bReference = tFalse;
        }
 
        if (m_pBitmap != NULL && psFormat->nSize == m_sFormat.nSize)
        {
            RETURN_NOERROR;
        }
 
        Free();
        if (m_sFormat.nBytesPerLine == 0)
        {
            m_sFormat.nBytesPerLine =
                CalcAlignedMemSize(m_sFormat.nWidth * m_sFormat.nBitsPerPixel / 8, m_nDefaultLineAlignment);
        }
 
        if (psFormat->nSize > 0)
        {
            RETURN_IF_FAILED(AllocImpl(psFormat->nSize, &m_hBitmapMemory, (tVoid**) &m_pBitmap));
        }
 
        adtf::util::cMemoryBlock::MemCopy(&m_sFormat, psFormat, sizeof(m_sFormat));
 
        RETURN_NOERROR;
    }

    tResult Free()
    {
        FreeBitmapInfo();
        FreePalette();
        adtf::util::cMemoryBlock::MemSet(&m_sFormat, 0, sizeof(m_sFormat));
 
        if (!m_bReference)
        {
            if (m_hBitmapMemory != NULL)
            {
                FreeImpl(m_hBitmapMemory);
                m_hBitmapMemory = NULL;
            }
            else if (m_pBitmap != NULL)
            {
                delete[] m_pBitmap;
            }
        }
 
        m_pBitmap = NULL;
        m_bReference = tFalse;
 
        RETURN_NOERROR;
    }

    tResult AllocImpl(tInt nSize, tHandle* hMemory, tVoid** pBuffer)
    {
        *hMemory = NULL;
        *pBuffer = NULL;
 
        tInt nMemBlockSize = nSize + m_nDefaultMemoryAlignment - 1;
 
        *hMemory = (tHandle) new tUInt8[nMemBlockSize];
        if (*hMemory == NULL)
        {
            RETURN_ERROR(ERR_MEMORY);
        }
 
        *pBuffer = (tUInt8*) ((reinterpret_cast<tMemoryAddress>(*hMemory) + m_nDefaultMemoryAlignment - 1) &
                              ~(m_nDefaultMemoryAlignment - 1));
 
        RETURN_NOERROR;
    }

    tResult FreeImpl(tHandle hMemory)
    {
        delete[] ((tUInt8*) hMemory);
 
        RETURN_NOERROR;
    }

    tResult AllocPalette(tInt nPaletteSize)
    {
        if (m_pPalette != NULL && nPaletteSize == m_sFormat.nPaletteSize)
        {
            RETURN_NOERROR;
        }
 
        FreePalette();
 
        if (nPaletteSize != 0)
        {
            m_pPalette = new tColor[nPaletteSize];
            if (m_pPalette == NULL)
            {
                RETURN_ERROR(ERR_MEMORY);
            }
        }
 
        RETURN_NOERROR;
    }

    tResult FreePalette()
    {
        if (m_pPalette != NULL)
        {
            delete[] m_pPalette;
            m_pPalette = NULL;
        }
 
        m_nGreyPaletteSize = 0;
        m_sFormat.nPaletteSize = 0;
 
        RETURN_NOERROR;
    }

    tResult AllocBitmapInfo()
    {
        FreeBitmapInfo();
 
        tInt l_nPaletteSize = m_sFormat.nPaletteSize;
        if (l_nPaletteSize == 0 && m_pPalette != NULL)
        {
            l_nPaletteSize = m_nGreyPaletteSize;
        }
 
        tInt nBitmapInfoSize = sizeof(tWin32BitmapInfo) + sizeof(tColor) * l_nPaletteSize;
 
        m_psBitmapInfo = (tWin32BitmapInfo*) new tUInt8[nBitmapInfoSize];
        if (m_psBitmapInfo == NULL)
        {
            RETURN_ERROR(ERR_MEMORY);
        }
 
        adtf::util::cMemoryBlock::MemSet(m_psBitmapInfo, 0, nBitmapInfoSize);
 
        m_nBitmapInfoSize = nBitmapInfoSize;
 
        tWin32BitmapInfoHeader* l_pHdr = &m_psBitmapInfo->sHeader;
        l_pHdr->nSize = sizeof(tWin32BitmapInfoHeader);
        l_pHdr->nWidth = m_sFormat.nWidth;
        l_pHdr->nHeight = m_sFormat.nHeight;
        l_pHdr->nPlanes = 1;
#ifdef WIN32
        l_pHdr->nBitCount = (WORD) m_sFormat.nBitsPerPixel;
        l_pHdr->nCompression = BI_RGB;
#else
        l_pHdr->nBitCount = (tUInt8) m_sFormat.nBitsPerPixel;
        l_pHdr->nCompression = 0L;
#endif
        l_pHdr->nSizeImage = m_sFormat.nSize;
        l_pHdr->nXPelsPerMeter = 0;
        l_pHdr->nYPelsPerMeter = 0;
        l_pHdr->nClrUsed = l_nPaletteSize;
        l_pHdr->nClrImportant = 0;
 
        if (l_nPaletteSize > 0 && m_pPalette != NULL)
        {
            tColor* l_aPalette = (tColor*) ((tUInt8*) m_psBitmapInfo + sizeof(tWin32BitmapInfoHeader));
            adtf::util::cMemoryBlock::MemCopy(l_aPalette, m_pPalette, l_nPaletteSize * sizeof(tColor));
        }
 
        RETURN_NOERROR;
    }

    tResult FreeBitmapInfo()
    {
        if (m_psBitmapInfo != NULL)
        {
            delete[] ((tUInt8*) m_psBitmapInfo);
            m_psBitmapInfo = NULL;
        }
 
        m_nBitmapInfoSize = 0;
 
        RETURN_NOERROR;
    }
 
protected: // internal blitting operations
    static tResult Blit_impl(const tUInt8* pSrcBitmapData,
                             const tBitmapFormat* psSrcBitmapFormat,
                             tUInt8* pDestBitmapData,
                             const tBitmapFormat* psDestBitmapFormat,
                             tInt nFlags)
    {
        RETURN_IF_POINTER_NULL(pSrcBitmapData);
        RETURN_IF_POINTER_NULL(psSrcBitmapFormat);
        RETURN_IF_POINTER_NULL(pDestBitmapData);
        RETURN_IF_POINTER_NULL(psDestBitmapFormat);
 
        if (psSrcBitmapFormat->nPixelFormat != psDestBitmapFormat->nPixelFormat)
        {
            return Convert_impl(pSrcBitmapData, psSrcBitmapFormat, pDestBitmapData, psDestBitmapFormat, nFlags, 0x0);
        }
 
        tInt l_nCopyWidth = std::min<tInt>(psSrcBitmapFormat->nBytesPerLine, psDestBitmapFormat->nBytesPerLine);
        tInt l_nCopyHeight = std::min<tInt>(psSrcBitmapFormat->nHeight, psDestBitmapFormat->nHeight);
 
        const tUInt8* l_pSrcLine = pSrcBitmapData;
        tUInt8* l_pDestLine = pDestBitmapData;
 
        if ((nFlags & BLIT_VerticalFlip) != 0)
        {
            l_pDestLine += psDestBitmapFormat->nBytesPerLine * (l_nCopyHeight - 1);
 
            for (tInt y = 0; y < l_nCopyHeight; y++)
            {
                adtf::util::cMemoryBlock::MemCopy(l_pDestLine, l_pSrcLine, l_nCopyWidth);
 
                l_pSrcLine += psSrcBitmapFormat->nBytesPerLine;
                l_pDestLine -= psDestBitmapFormat->nBytesPerLine;
            }
        }
        else
        {
            if (psSrcBitmapFormat->nBytesPerLine == psDestBitmapFormat->nBytesPerLine)
            {
                adtf::util::cMemoryBlock::MemCopy(l_pDestLine, l_pSrcLine,
                                                  l_nCopyHeight * psSrcBitmapFormat->nBytesPerLine);
            }
            else
            {
                for (tInt y = 0; y < l_nCopyHeight; y++)
                {
                    adtf::util::cMemoryBlock::MemCopy(l_pDestLine, l_pSrcLine, l_nCopyWidth);
 
                    l_pSrcLine += psSrcBitmapFormat->nBytesPerLine;
                    l_pDestLine += psDestBitmapFormat->nBytesPerLine;
                }
            }
        }
 
        RETURN_NOERROR;
    }

    static tResult StretchBlit_impl(const tUInt8* pSrcBitmapData,
                                    const tBitmapFormat* psSrcBitmapFormat,
                                    tUInt8* pDestBitmapData,
                                    const tBitmapFormat* psDestBitmapFormat,
                                    tInt nFlags,
                                    tUInt32 ui32Mask = 0x0)
    {
        RETURN_IF_POINTER_NULL(pSrcBitmapData);
        RETURN_IF_POINTER_NULL(psSrcBitmapFormat);
        RETURN_IF_POINTER_NULL(pDestBitmapData);
        RETURN_IF_POINTER_NULL(psDestBitmapFormat);
 
        cImage oTempImage;
        if (psSrcBitmapFormat->nBitsPerPixel != psDestBitmapFormat->nBitsPerPixel)
        {
            if (psSrcBitmapFormat->nWidth == psDestBitmapFormat->nWidth &&
                psSrcBitmapFormat->nHeight == psDestBitmapFormat->nHeight)
            {
                return Convert_impl(pSrcBitmapData, psSrcBitmapFormat, pDestBitmapData, psDestBitmapFormat, nFlags,
                                    ui32Mask);
            }
            else
            {
                tBitmapFormat oNewFormat;
                adtf::util::cMemoryBlock::MemCopy(&oNewFormat, psSrcBitmapFormat, sizeof(tBitmapFormat));
                oNewFormat.nBitsPerPixel = psDestBitmapFormat->nBitsPerPixel;
                oNewFormat.nBytesPerLine = CalcAlignedMemSize(oNewFormat.nWidth * oNewFormat.nBitsPerPixel / 8,
                                                              cImage::m_nDefaultLineAlignment);
                oNewFormat.nPixelFormat = psDestBitmapFormat->nPixelFormat;
 
                RETURN_IF_FAILED(oTempImage.Create(psSrcBitmapFormat->nWidth, psSrcBitmapFormat->nHeight,
                                                   psDestBitmapFormat->nBitsPerPixel, 0, NULL,
                                                   psDestBitmapFormat->nPixelFormat));
                RETURN_IF_FAILED(
                    Convert_impl(pSrcBitmapData, psSrcBitmapFormat, oTempImage.GetBitmap(), &oNewFormat, nFlags, 0x0));
                pSrcBitmapData = oTempImage.GetBitmap();
                psSrcBitmapFormat = oTempImage.GetFormat();
            }
        }
 
        if (psSrcBitmapFormat->nWidth == psDestBitmapFormat->nWidth &&
            psSrcBitmapFormat->nHeight == psDestBitmapFormat->nHeight)
        {
            return Blit(pSrcBitmapData, psSrcBitmapFormat, pDestBitmapData, psDestBitmapFormat, nFlags);
        }
 
        tInt l_nCopyWidth = psDestBitmapFormat->nWidth;
        tInt l_nCopyHeight = psDestBitmapFormat->nHeight;
 
        const tUInt8* l_pSrcLine = pSrcBitmapData;
        tUInt8* l_pDestLine = pDestBitmapData;
        tInt l_nBytesPerPixel = psSrcBitmapFormat->nBitsPerPixel / 8;
 
        tInt nCopySrcStep = psSrcBitmapFormat->nWidth;
        tInt nCopySrcMax = l_nCopyWidth * nCopySrcStep;
 
        tInt y2;
        tInt x2;
 
        for (tInt y = 0; y < l_nCopyHeight; y++)
        {
            y2 = tInt(y * tFloat(psSrcBitmapFormat->nHeight) / l_nCopyHeight);
 
            l_pSrcLine = pSrcBitmapData + y2 * psSrcBitmapFormat->nBytesPerLine;
            l_pDestLine = pDestBitmapData + y * psDestBitmapFormat->nBytesPerLine;
 
            if (l_nBytesPerPixel == 1)
            {
                for (tInt x = 0; x < nCopySrcMax; x += nCopySrcStep)
                {
                    *(l_pDestLine++) = *(l_pSrcLine + x / l_nCopyWidth);
                }
            }
            else if (l_nBytesPerPixel == 2)
            {
                tUInt16* l_pui16SrcLine = (tUInt16*) l_pSrcLine;
                tUInt16* l_pui16DestLine = (tUInt16*) l_pDestLine;
 
                for (tInt x = 0; x < nCopySrcMax; x += nCopySrcStep)
                {
                    *(l_pui16DestLine++) = *(l_pui16SrcLine + x / l_nCopyWidth);
                }
            }
            else if (l_nBytesPerPixel == 3)
            {
                const tUInt8* l_pSrc;
                tUInt8* l_pDest;
                for (tInt x = 0; x < l_nCopyWidth; x++)
                {
                    x2 = tInt(x * tFloat(psSrcBitmapFormat->nWidth) / l_nCopyWidth);
 
                    l_pDest = l_pDestLine + x * l_nBytesPerPixel;
                    l_pSrc = l_pSrcLine + x2 * l_nBytesPerPixel;
 
                    *l_pDest++ = *l_pSrc++;
                    *l_pDest++ = *l_pSrc++;
                    *l_pDest++ = *l_pSrc++;
                }
            }
            else if (l_nBytesPerPixel == 4)
            {
                tUInt32* l_pui32SrcLine = (tUInt32*) l_pSrcLine;
                tUInt32* l_pui32DestLine = (tUInt32*) l_pDestLine;
 
                for (tInt x = 0; x < nCopySrcMax; x += nCopySrcStep)
                {
                    *(l_pui32DestLine++) = *(l_pui32SrcLine + x / l_nCopyWidth);
                }
            }
        }
 
        RETURN_NOERROR;
    }

    static tResult Convert_impl(const tUInt8* pSrcBitmapData,
                                const tBitmapFormat* psSrcBitmapFormat,
                                tUInt8* pDestBitmapData,
                                const tBitmapFormat* psDestBitmapFormat,
                                tInt nFlags,
                                tUInt32 ui32Mask)
    {
        if (psSrcBitmapFormat->nPixelFormat == IImage::PF_UNKNOWN ||
            psDestBitmapFormat->nPixelFormat == IImage::PF_UNKNOWN)
        {
            RETURN_ERROR(ERR_UNKNOWN_FORMAT);
        }
 
        if (psSrcBitmapFormat->nPixelFormat == IImage::PF_CUSTOM ||
            psDestBitmapFormat->nPixelFormat == IImage::PF_CUSTOM)
        {
            RETURN_ERROR(ERR_UNKNOWN_FORMAT);
        }
 
        if (psSrcBitmapFormat->nPixelFormat == PF_YUV420P_888 || psDestBitmapFormat->nPixelFormat == PF_YUV420P_888)
        {
            RETURN_ERROR(ERR_NOT_SUPPORTED);
        }
 
        const tUInt8* l_pSrcLine = pSrcBitmapData;
        tUInt8* l_pDestLine = pDestBitmapData;
 
        tInt l_nSrcBytesPerPixel = psSrcBitmapFormat->nBitsPerPixel / 8;
        tInt l_nDestBytesPerPixel = psDestBitmapFormat->nBitsPerPixel / 8;
 
        tInt l_nCopyWidth = std::min<tInt>(psSrcBitmapFormat->nWidth, psDestBitmapFormat->nWidth);
        tInt l_nCopyHeight = std::min<tInt>(psSrcBitmapFormat->nHeight, psDestBitmapFormat->nHeight);
        tUInt16 c16;
        tUInt8 nRed, nGreen, nBlue;
 
        // this is removed because it makes no sense to copy the smaller image onto the lower end
        // of the destination image
        // if (psSrcBitmapFormat->nHeight >= psDestBitmapFormat->nHeight)
        //{
        //    l_pSrcLine += (psSrcBitmapFormat->nHeight - psDestBitmapFormat->nHeight) *
        //    psSrcBitmapFormat->nBytesPerLine;
        //}
        // else
        //{
        //    l_pDestLine += (psDestBitmapFormat->nHeight - psSrcBitmapFormat->nHeight) *
        //    psDestBitmapFormat->nBytesPerLine;
        //}
 
        tInt nShiftBits = 0;
        if (ui32Mask != 0x0)
        {
            tUInt32 ui32TempMask;
            for (ui32TempMask = ui32Mask; !(ui32TempMask & 0x01); ui32TempMask >>= 1)
            {
                ++nShiftBits;
            }
 
            tInt nDataBits = 0;
            for (; (ui32TempMask & 0x01); ui32TempMask >>= 1)
            {
                ++nDataBits;
            }
 
            nShiftBits -=
                std::min<tInt>(psSrcBitmapFormat->nBitsPerPixel, psDestBitmapFormat->nBitsPerPixel) - nDataBits;
            if (nShiftBits < 0)
            {
                nShiftBits = 0;
            }
        }
 
        tBool bVFlip = ((nFlags & BLIT_VerticalFlip) != 0);
 
        if (bVFlip)
        {
            l_pDestLine += (l_nCopyHeight - 1) * psDestBitmapFormat->nBytesPerLine;
        }
 
        // conversion
        for (tInt y = 0; y < l_nCopyHeight; y++)
        {
            // no conversion is needed
            if (psDestBitmapFormat->nPixelFormat == psSrcBitmapFormat->nPixelFormat)
            {
                adtf::util::cMemoryBlock::MemCopy(l_pDestLine, l_pSrcLine, l_nCopyWidth * l_nSrcBytesPerPixel);
            }
            else if (l_nSrcBytesPerPixel == 1)
            {
                if (0 != psSrcBitmapFormat->nPaletteSize)
                {
                    RETURN_ERROR(ERR_NOT_SUPPORTED);
                }
 
                const tUInt8* l_pSrc = l_pSrcLine;
                tUInt8 c8;
 
                if (l_nDestBytesPerPixel == 3)
                {
                    tUInt8* l_pDest = l_pDestLine;
                    for (tInt x = 0; x < l_nCopyWidth; x++)
                    {
                        c8 = *(l_pSrc++);
 
                        *(l_pDest++) = c8;
                        *(l_pDest++) = c8;
                        *(l_pDest++) = c8;
                    }
                }
                else if (l_nDestBytesPerPixel == 4)
                {
                    tUInt32* l_pDest = (tUInt32*) l_pDestLine;
                    tInt rs = 0, gs = 0, bs = 0;
 
                    switch (psDestBitmapFormat->nPixelFormat)
                    {
                        case PF_RGBA_8888:
                        case PF_BGRA_8888:
                        {
                            rs = 0;
                            gs = 8;
                            bs = 16;
                        }
                        break;
 
                        case PF_ARGB_8888:
                        case PF_ABGR_8888:
                        {
                            rs = 8;
                            gs = 16;
                            bs = 24;
                        }
                        break;
 
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    for (tInt x = 0; x < l_nCopyWidth; x++)
                    {
                        tUInt32 k8 = *(l_pSrc++);
                        *l_pDest++ = (k8 << bs) | (k8 << gs) | (k8 << rs);
                    }
                }
                else if (l_nDestBytesPerPixel == 2)
                {
                    tUInt16* l_pDest = (tUInt16*) l_pDestLine;
 
                    if (psDestBitmapFormat->nPixelFormat == PF_RGB_555)
                    {
                        for (tInt x = 0; x < l_nCopyWidth; x++)
                        {
                            c8 = *(l_pSrc++);
                            *(l_pDest++) = RGB555(c8, c8, c8);
                        }
                    }
                    else if (psDestBitmapFormat->nPixelFormat == PF_RGB_565)
                    {
                        for (tInt x = 0; x < l_nCopyWidth; x++)
                        {
                            c8 = *(l_pSrc++);
                            *(l_pDest++) = RGB565(c8, c8, c8);
                        }
                    }
                    else
                    {
                        if (ui32Mask == 0)
                        {
                            for (tInt x = 0; x < l_nCopyWidth; x++)
                            {
                                c8 = *(l_pSrc++);
                                *(l_pDest++) = (((tUInt16) c8) << 8);
                            }
                        }
                        else
                        {
                            for (tInt x = 0; x < l_nCopyWidth; x++)
                            {
                                c8 = *(l_pSrc++);
                                *(l_pDest++) = (tUInt16) ((((tUInt32) c8) << nShiftBits) & ui32Mask);
                            }
                        }
                    }
                }
            }
            else if (l_nSrcBytesPerPixel == 2)
            {
                if (l_nDestBytesPerPixel == 1)
                {
                    tUInt16* l_pSrc = (tUInt16*) l_pSrcLine;
                    tUInt8* l_pDest = l_pDestLine;
                    if (psSrcBitmapFormat->nPixelFormat == PF_RGB_555)
                    {
                        for (tInt x = 0; x < l_nCopyWidth; x++)
                        {
                            c16 = *(l_pSrc++);
                            nRed = GetRed_RGB555(c16);
                            nGreen = GetGreen_RGB555(c16);
                            nBlue = GetBlue_RGB555(c16);
                            *(l_pDest++) = Brightness((tInt) nRed, (tInt) nGreen, (tInt) nBlue);
                        }
                    }
                    else if (psSrcBitmapFormat->nPixelFormat == PF_RGB_565)
                    {
                        for (tInt x = 0; x < l_nCopyWidth; x++)
                        {
                            c16 = *(l_pSrc++);
                            nRed = GetRed_RGB565(c16);
                            nGreen = GetGreen_RGB565(c16);
                            nBlue = GetBlue_RGB565(c16);
                            *(l_pDest++) = Brightness((tInt) nRed, (tInt) nGreen, (tInt) nBlue);
                        }
                    }
                    else
                    {
                        if (ui32Mask == 0)
                        {
                            for (tInt x = 0; x < l_nCopyWidth; x++)
                            {
                                *(l_pDest++) = (tUInt8) (*(l_pSrc++) >> 8);
                            }
                        }
                        else
                        {
                            for (tInt x = 0; x < l_nCopyWidth; x++)
                            {
                                *(l_pDest++) = (tUInt8) (((*(l_pSrc++)) & ui32Mask) >> nShiftBits);
                            }
                        }
                    }
                }
                else if (l_nDestBytesPerPixel == 2)
                {
                    tUInt16* l_pDest = (tUInt16*) l_pDestLine;
                    tUInt16* l_pSrc = (tUInt16*) l_pSrcLine;
 
                    tInt iSRPos, iSGPos, iSBPos, iSAPos = 16;
                    tInt iDRPos, iDGPos, iDBPos, iDAPos = 16;
                    tUInt16 iSMask, iSGMask, iSAMask = 0;
                    tUInt16 iDMask, iDGMask, iDAMask = 0;
 
                    switch (psSrcBitmapFormat->nPixelFormat)
                    {
                        case PF_RGB_444:
                            iSRPos = 0;
                            iSGPos = 4;
                            iSBPos = 8;
                            iSMask = iSGMask = 0xf;
                            break;
                        case PF_RGB_555:
                            iSRPos = 0;
                            iSGPos = 5;
                            iSBPos = 10;
                            iSMask = iSGMask = 0x1f;
                            break;
                        case PF_BGR_555:
                            iSRPos = 10;
                            iSGPos = 5;
                            iSBPos = 0;
                            iSMask = iSGMask = 0x1f;
                            break;
                        case PF_RGB_565:
                            iSRPos = 0;
                            iSGPos = 5;
                            iSBPos = 11;
                            iSMask = 0x1f;
                            iSGMask = 0x3f;
                            break;
                        case PF_BGR_565:
                            iSRPos = 11;
                            iSGPos = 5;
                            iSBPos = 0;
                            iSMask = 0x1f;
                            iSGMask = 0x3f;
                            break;
                        case PF_RGBA_4444:
                            iSRPos = 0;
                            iSGPos = 4;
                            iSBPos = 8;
                            iSAPos = 12;
                            iSMask = iSGMask = 0xf;
                            iSAMask = 0xf;
                            break;
                        case PF_ABGR_4444:
                            iSAPos = 0;
                            iSBPos = 4;
                            iSGPos = 8;
                            iSRPos = 12;
                            iSMask = iSGMask = 0xf;
                            iSAMask = 0xf;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    switch (psDestBitmapFormat->nPixelFormat)
                    {
                        case PF_RGB_444:
                            iDRPos = 0;
                            iDGPos = 4;
                            iDBPos = 8;
                            iDMask = iDGMask = 0xf;
                            break;
                        case PF_RGB_555:
                            iDRPos = 0;
                            iDGPos = 5;
                            iDBPos = 10;
                            iDMask = iDGMask = 0x1f;
                            break;
                        case PF_BGR_555:
                            iDRPos = 10;
                            iDGPos = 5;
                            iDBPos = 0;
                            iDMask = iDGMask = 0x1f;
                            break;
                        case PF_RGB_565:
                            iDRPos = 0;
                            iDGPos = 5;
                            iDBPos = 11;
                            iDMask = 0x1f;
                            iDGMask = 0x3f;
                            break;
                        case PF_BGR_565:
                            iDRPos = 11;
                            iDGPos = 5;
                            iDBPos = 0;
                            iDMask = 0x1f;
                            iDGMask = 0x3f;
                            break;
                        case PF_RGBA_4444:
                            iDRPos = 0;
                            iDGPos = 4;
                            iDBPos = 8;
                            iDAPos = 12;
                            iDMask = iDGMask = 0xf;
                            iDAMask = 0xf;
                            break;
                        case PF_ABGR_4444:
                            iDAPos = 0;
                            iDBPos = 4;
                            iDGPos = 8;
                            iDRPos = 12;
                            iDMask = iDGMask = 0xf;
                            iDAMask = 0xf;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    tUInt16 iDRMask = iDMask;
                    tUInt16 iDBMask = iDMask;
                    tUInt16 iSRMask = iSMask;
                    tUInt16 iSBMask = iSMask;
 
                    iDRMask = AdjustMasks(iSRMask, iDRMask, iSRPos);
                    iDBMask = AdjustMasks(iSBMask, iDBMask, iSBPos);
                    iDGMask = AdjustMasks(iSGMask, iDGMask, iSGPos);
                    iSAMask = AdjustMasks(iSAMask, iDAMask, iSAPos);
 
                    if (iSRPos < 0)
                    {
                        iDRPos -= iSRPos;
                        iDRMask >>= -iSRPos;
                        iSRPos = 0;
                    }
 
                    for (tInt x = 0; x < l_nCopyWidth; x++)
                    {
                        tUInt16 c = *l_pSrc++;
 
                        *l_pDest++ = (((c >> iSRPos) & iDRMask) << iDRPos) | (((c >> iSGPos) & iDGMask) << iDGPos) |
                                     (((c >> iSBPos) & iDBMask) << iDBPos) | (((c >> iSAPos) & iSAMask) << iDAPos);
                    }
                }
                else if (l_nDestBytesPerPixel == 3)
                {
                    tUInt8* l_pDest = l_pDestLine;
                    tUInt16* l_pSrc = (tUInt16*) l_pSrcLine;
 
                    tInt iSl, iSRr, iSGl, iSGr, iSBr;
                    tInt iDR, iDB;
 
                    switch (psSrcBitmapFormat->nPixelFormat)
                    {
                        case PF_RGB_555:
                            iSRr = 0;
                            iSGr = 5;
                            iSBr = 10;
                            iSl = iSGl = 3;
                            break;
                        case PF_RGB_565:
                            iSRr = 0;
                            iSGr = 5;
                            iSBr = 11;
                            iSl = 3;
                            iSGl = 2;
                            break;
                        case PF_BGR_555:
                            iSRr = 10;
                            iSGr = 5;
                            iSBr = 0;
                            iSl = iSGl = 3;
                            break;
                        case PF_BGR_565:
                            iSRr = 11;
                            iSGr = 5;
                            iSBr = 0;
                            iSl = 3;
                            iSGl = 2;
                            break;
                        case PF_RGB_444:
                            iSRr = 0;
                            iSGr = 4;
                            iSBr = 8;
                            iSl = iSGl = 4;
                            break;
                        case PF_RGBA_4444:
                            iSRr = 0;
                            iSGr = 4;
                            iSBr = 8;
                            iSl = iSGl = 4;
                            break;
                        case PF_ABGR_4444:
                            iSRr = 12;
                            iSGr = 8;
                            iSBr = 4;
                            iSl = iSGl = 4;
                            break;
                        case PF_GREYSCALE_16:
                            iSRr = 8;
                            iSGr = 8;
                            iSBr = 8;
                            iSl = iSGl = 0;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    switch (psDestBitmapFormat->nPixelFormat)
                    {
                        case PF_RGB_888:
                            iDR = 0;
                            iDB = 2;
                            break;
                        case PF_BGR_888:
                            iDR = 2;
                            iDB = 0;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    for (tInt x = 0; x < l_nCopyWidth; x++)
                    {
                        tUInt16 const k16 = *l_pSrc++;
                        l_pDest[iDR] = static_cast<uint8_t>((k16 >> iSRr) << iSl);
                        l_pDest[1] = static_cast<uint8_t>((k16 >> iSGr) << iSGl);
                        l_pDest[iDB] = static_cast<uint8_t>((k16 >> iSBr) << iSl);
                        l_pDest += 3;
                    }
                }
                else if (l_nDestBytesPerPixel == 4)
                {
                    tUInt8* l_pDest = l_pDestLine;
                    tUInt16* l_pSrc = (tUInt16*) l_pSrcLine;
 
                    tInt iSl, iSRr, iSGl, iSGr, iSBr, iSAr = 16;
 
                    switch (psSrcBitmapFormat->nPixelFormat)
                    {
                        case PF_RGB_555:
                            iSRr = 0;
                            iSGr = 5;
                            iSBr = 10;
                            iSl = iSGl = 3;
                            break;
                        case PF_RGB_565:
                            iSRr = 0;
                            iSGr = 5;
                            iSBr = 11;
                            iSl = 3;
                            iSGl = 2;
                            break;
                        case PF_BGR_555:
                            iSRr = 10;
                            iSGr = 5;
                            iSBr = 0;
                            iSl = iSGl = 3;
                            break;
                        case PF_BGR_565:
                            iSRr = 11;
                            iSGr = 5;
                            iSBr = 0;
                            iSl = 3;
                            iSGl = 2;
                            break;
                        case PF_RGB_444:
                            iSRr = 0;
                            iSGr = 4;
                            iSBr = 8;
                            iSl = iSGl = 4;
                            break;
                        case PF_RGBA_4444:
                            iSRr = 0;
                            iSGr = 4;
                            iSBr = 8;
                            iSl = iSGl = 4;
                            iSAr = 12;
                            break;
                        case PF_ABGR_4444:
                            iSRr = 12;
                            iSGr = 8;
                            iSBr = 4;
                            iSl = iSGl = 4;
                            iSAr = 0;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    tInt iDR, iDG, iDB, iDA;
 
                    switch (psDestBitmapFormat->nPixelFormat)
                    {
                        case PF_ARGB_8888:
                            iDA = 0;
                            iDR = 1;
                            iDG = 2;
                            iDB = 3;
                            break;
                        case PF_ABGR_8888:
                            iDA = 0;
                            iDR = 3;
                            iDG = 2;
                            iDB = 1;
                            break;
                        case PF_RGBA_8888:
                            iDA = 3;
                            iDR = 0;
                            iDG = 1;
                            iDB = 2;
                            break;
                        case PF_BGRA_8888:
                            iDA = 3;
                            iDR = 2;
                            iDG = 1;
                            iDB = 0;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    for (tInt x = 0; x < l_nCopyWidth; x++)
                    {
                        tUInt16 const k16 = *l_pSrc++;
                        l_pDest[iDR] = static_cast<uint8_t>((k16 >> iSRr) << iSl);
                        l_pDest[iDG] = static_cast<uint8_t>((k16 >> iSGr) << iSGl);
                        l_pDest[iDB] = static_cast<uint8_t>((k16 >> iSBr) << iSl);
                        l_pDest[iDA] = static_cast<uint8_t>((k16 >> iSAr) << iSl);
                        l_pDest += 4;
                    }
                }
            }
            else if (l_nSrcBytesPerPixel == 3)
            {
                const tUInt8* l_pSrc = l_pSrcLine;
                if (l_nDestBytesPerPixel == 1)
                {
                    if (PF_GREYSCALE_8 != psDestBitmapFormat->nPixelFormat)
                    {
                        RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    tUInt8* l_pDest = l_pDestLine;
                    tInt ri = 0, gi = 0, bi = 0;
 
                    switch (psSrcBitmapFormat->nPixelFormat)
                    {
                        case PF_RGB_888:
                            ri = 0;
                            gi = 1;
                            bi = 2;
                            break;
                        case PF_BGR_888:
                            ri = 2;
                            gi = 1;
                            bi = 0;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    for (tInt x = 0; x < l_nCopyWidth; x++)
                    {
                        *(l_pDest++) = Brightness(l_pSrc[ri], l_pSrc[gi], l_pSrc[bi]);
                        l_pSrc += 3;
                    }
                }
                else if (l_nDestBytesPerPixel == 2)
                {
                    tUInt16* l_pDest = (tUInt16*) l_pDestLine;
                    tInt iSR, iSB;
 
                    switch (psSrcBitmapFormat->nPixelFormat)
                    {
                        case PF_RGB_888:
                            iSR = 0;
                            iSB = 2;
                            break;
                        case PF_BGR_888:
                            iSR = 2;
                            iSB = 0;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    tInt iDr, iDRl, iDGr, iDGl, iDBl, iDAl = 16;
                    tBool bDestGrey = tFalse;
 
                    switch (psDestBitmapFormat->nPixelFormat)
                    {
                        case PF_RGB_555:
                            iDRl = 0;
                            iDGl = 5;
                            iDBl = 10;
                            iDr = iDGr = 3;
                            break;
                        case PF_RGB_565:
                            iDRl = 0;
                            iDGl = 5;
                            iDBl = 11;
                            iDr = 3;
                            iDGr = 2;
                            break;
                        case PF_BGR_555:
                            iDRl = 10;
                            iDGl = 5;
                            iDBl = 0;
                            iDr = iDGr = 3;
                            break;
                        case PF_BGR_565:
                            iDRl = 11;
                            iDGl = 5;
                            iDBl = 0;
                            iDr = 3;
                            iDGr = 2;
                            break;
                        case PF_RGB_444:
                            iDRl = 0;
                            iDGl = 4;
                            iDBl = 8;
                            iDr = iDGr = 4;
                            break;
                        case PF_RGBA_4444:
                            iDRl = 0;
                            iDGl = 4;
                            iDBl = 8;
                            iDr = iDGr = 4;
                            iDAl = 12;
                            break;
                        case PF_ABGR_4444:
                            iDRl = 12;
                            iDGl = 8;
                            iDBl = 4;
                            iDr = iDGr = 4;
                            iDAl = 0;
                            break;
                        case PF_GREYSCALE_16: bDestGrey = tTrue; break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    if (bDestGrey)
                    {
                        for (tInt x = 0; x < l_nCopyWidth; x++)
                        {
                            *l_pDest++ = static_cast<uint16_t>(
                                cImage::BrightnessValue(l_pSrc[iSR], l_pSrc[1], l_pSrc[iSB]) >> 2);
                            l_pSrc += 3;
                        }
                    }
                    else
                    {
                        for (tInt x = 0; x < l_nCopyWidth; x++)
                        {
                            *l_pDest++ =
                                (((tUInt16) l_pSrc[iSR] >> iDr) << iDRl) | (((tUInt16) l_pSrc[1] >> iDGr) << iDGl) |
                                (((tUInt16) l_pSrc[iSB] >> iDr) << iDBl) | (((tUInt16) ALPHA_DEFAULT >> iDr) << iDAl);
                            l_pSrc += 3;
                        }
                    }
                }
                else if (l_nDestBytesPerPixel == 3)
                {
                    tUInt8* l_pDest = l_pDestLine;
 
                    tInt iDR, iDB, iSR, iSB;
 
                    switch (psSrcBitmapFormat->nPixelFormat)
                    {
                        case PF_RGB_888:
                            iSR = 0;
                            iSB = 2;
                            break;
                        case PF_BGR_888:
                            iSR = 2;
                            iSB = 0;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    switch (psDestBitmapFormat->nPixelFormat)
                    {
                        case PF_RGB_888:
                            iDR = 0;
                            iDB = 2;
                            break;
                        case PF_BGR_888:
                            iDR = 2;
                            iDB = 0;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    for (tInt x = 0; x < l_nCopyWidth; x++)
                    {
                        l_pDest[iDR] = l_pSrc[iSR];
                        l_pDest[1] = l_pSrc[1];
                        l_pDest[iDB] = l_pSrc[iSB];
                        l_pDest += 3;
                        l_pSrc += 3;
                    }
                }
                else if (l_nDestBytesPerPixel == 4)
                {
                    tUInt8* l_pDest = l_pDestLine;
 
                    tInt iSR, iSG, iSB;
                    tInt iDR, iDG, iDB, iDA;
 
                    switch (psSrcBitmapFormat->nPixelFormat)
                    {
                        case PF_RGB_888:
                            iSR = 0;
                            iSG = 1;
                            iSB = 2;
                            break;
                        case PF_BGR_888:
                            iSR = 2;
                            iSG = 1;
                            iSB = 0;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    switch (psDestBitmapFormat->nPixelFormat)
                    {
                        case PF_ARGB_8888:
                            iDA = 0;
                            iDR = 1;
                            iDG = 2;
                            iDB = 3;
                            break;
                        case PF_ABGR_8888:
                            iDA = 0;
                            iDR = 3;
                            iDG = 2;
                            iDB = 1;
                            break;
                        case PF_RGBA_8888:
                            iDA = 3;
                            iDR = 0;
                            iDG = 1;
                            iDB = 2;
                            break;
                        case PF_BGRA_8888:
                            iDA = 3;
                            iDR = 2;
                            iDG = 1;
                            iDB = 0;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    for (tInt x = 0; x < l_nCopyWidth; x++)
                    {
                        l_pDest[iDR] = l_pSrc[iSR];
                        l_pDest[iDG] = l_pSrc[iSG];
                        l_pDest[iDB] = l_pSrc[iSB];
                        l_pDest[iDA] = ALPHA_DEFAULT;
                        l_pDest += 4;
                        l_pSrc += 3;
                    }
                }
            }
            else if (l_nSrcBytesPerPixel == 4)
            {
                if (l_nDestBytesPerPixel == 1)
                {
                    if (PF_GREYSCALE_8 != psDestBitmapFormat->nPixelFormat)
                    {
                        RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    tUInt8* l_pSrc = (tUInt8*) l_pSrcLine;
                    tUInt8* l_pDest = l_pDestLine;
                    tInt ri = 0, gi = 0, bi = 0;
 
                    switch (psSrcBitmapFormat->nPixelFormat)
                    {
                        case PF_RGBA_8888:
                            ri = 0;
                            gi = 1;
                            bi = 2;
                            break;
                        case PF_BGRA_8888:
                            ri = 2;
                            gi = 1;
                            bi = 0;
                            break;
                        case PF_ARGB_8888:
                            ri = 1;
                            gi = 2;
                            bi = 3;
                            break;
                        case PF_ABGR_8888:
                            ri = 3;
                            gi = 2;
                            bi = 1;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    for (tInt x = 0; x < l_nCopyWidth; x++)
                    {
                        *(l_pDest++) = Brightness(l_pSrc[ri], l_pSrc[gi], l_pSrc[bi]);
                        l_pSrc += 4;
                    }
                }
                else if (l_nDestBytesPerPixel == 2)
                {
                    tUInt16* l_pDest = (tUInt16*) l_pDestLine;
                    tUInt8* l_pSrc = (tUInt8*) l_pSrcLine;
 
                    tInt iSR, iSG, iSB, iSA;
 
                    switch (psSrcBitmapFormat->nPixelFormat)
                    {
                        case PF_RGBA_8888:
                            iSR = 0;
                            iSG = 1;
                            iSB = 2;
                            iSA = 3;
                            break;
                        case PF_BGRA_8888:
                            iSR = 2;
                            iSG = 1;
                            iSB = 0;
                            iSA = 3;
                            break;
                        case PF_ARGB_8888:
                            iSR = 1;
                            iSG = 2;
                            iSB = 3;
                            iSA = 0;
                            break;
                        case PF_ABGR_8888:
                            iSR = 3;
                            iSG = 2;
                            iSB = 1;
                            iSA = 0;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    tInt iDr, iDRl, iDGr, iDGl, iDBl, iDAl = 16;
 
                    switch (psDestBitmapFormat->nPixelFormat)
                    {
                        case PF_RGB_555:
                            iDRl = 0;
                            iDGl = 5;
                            iDBl = 10;
                            iDr = iDGr = 3;
                            break;
                        case PF_RGB_565:
                            iDRl = 0;
                            iDGl = 5;
                            iDBl = 11;
                            iDr = 3;
                            iDGr = 2;
                            break;
                        case PF_BGR_555:
                            iDRl = 10;
                            iDGl = 5;
                            iDBl = 0;
                            iDr = iDGr = 3;
                            break;
                        case PF_BGR_565:
                            iDRl = 11;
                            iDGl = 5;
                            iDBl = 0;
                            iDr = 3;
                            iDGr = 2;
                            break;
                        case PF_RGB_444:
                            iDRl = 0;
                            iDGl = 4;
                            iDBl = 8;
                            iDr = iDGr = 4;
                            break;
                        case PF_RGBA_4444:
                            iDRl = 0;
                            iDGl = 4;
                            iDBl = 8;
                            iDr = iDGr = 4;
                            iDAl = 12;
                            break;
                        case PF_ABGR_4444:
                            iDRl = 12;
                            iDGl = 8;
                            iDBl = 4;
                            iDr = iDGr = 4;
                            iDAl = 0;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    for (tInt x = 0; x < l_nCopyWidth; x++)
                    {
                        *l_pDest++ =
                            (((tUInt16) l_pSrc[iSR] >> iDr) << iDRl) | (((tUInt16) l_pSrc[iSG] >> iDGr) << iDGl) |
                            (((tUInt16) l_pSrc[iSB] >> iDr) << iDBl) | (((tUInt16) l_pSrc[iSA] >> iDr) << iDAl);
                        l_pSrc += 4;
                    }
                }
                else if (l_nDestBytesPerPixel == 3)
                {
                    const tUInt8* l_pSrc = l_pSrcLine;
                    tUInt8* l_pDest = l_pDestLine;
 
                    tInt iDR, iDG, iDB;
                    tInt iSR, iSG, iSB;
 
                    switch (psSrcBitmapFormat->nPixelFormat)
                    {
                        case PF_ARGB_8888:
                            iSR = 1;
                            iSG = 2;
                            iSB = 3;
                            break;
                        case PF_ABGR_8888:
                            iSR = 3;
                            iSG = 2;
                            iSB = 1;
                            break;
                        case PF_RGBA_8888:
                            iSR = 0;
                            iSG = 1;
                            iSB = 2;
                            break;
                        case PF_BGRA_8888:
                            iSR = 2;
                            iSG = 1;
                            iSB = 0;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    switch (psDestBitmapFormat->nPixelFormat)
                    {
                        case PF_RGB_888:
                            iDR = 0;
                            iDG = 1;
                            iDB = 2;
                            break;
                        case PF_BGR_888:
                            iDR = 2;
                            iDG = 1;
                            iDB = 0;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    for (tInt x = 0; x < l_nCopyWidth; x++)
                    {
                        l_pDest[iDR] = l_pSrc[iSR];
                        l_pDest[iDG] = l_pSrc[iSG];
                        l_pDest[iDB] = l_pSrc[iSB];
                        l_pSrc += 4;
                        l_pDest += 3;
                    }
                }
                else if (l_nDestBytesPerPixel == 4)
                {
                    const tUInt8* l_pSrc = l_pSrcLine;
                    tUInt8* l_pDest = (tUInt8*) l_pDestLine;
 
                    tInt iSA, iSR, iSG, iSB;
                    switch (psSrcBitmapFormat->nPixelFormat)
                    {
                        case PF_ARGB_8888:
                            iSA = 0;
                            iSR = 1;
                            iSG = 2;
                            iSB = 3;
                            break;
                        case PF_ABGR_8888:
                            iSA = 0;
                            iSR = 3;
                            iSG = 2;
                            iSB = 1;
                            break;
                        case PF_RGBA_8888:
                            iSA = 3;
                            iSR = 0;
                            iSG = 1;
                            iSB = 2;
                            break;
                        case PF_BGRA_8888:
                            iSA = 3;
                            iSR = 2;
                            iSG = 1;
                            iSB = 0;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    tInt iDA, iDR, iDG, iDB;
                    switch (psDestBitmapFormat->nPixelFormat)
                    {
                        case PF_ARGB_8888:
                            iDA = 0;
                            iDR = 1;
                            iDG = 2;
                            iDB = 3;
                            break;
                        case PF_ABGR_8888:
                            iDA = 0;
                            iDR = 3;
                            iDG = 2;
                            iDB = 1;
                            break;
                        case PF_RGBA_8888:
                            iDA = 3;
                            iDR = 0;
                            iDG = 1;
                            iDB = 2;
                            break;
                        case PF_BGRA_8888:
                            iDA = 3;
                            iDR = 2;
                            iDG = 1;
                            iDB = 0;
                            break;
                        default: RETURN_ERROR(ERR_NOT_SUPPORTED);
                    }
 
                    for (tInt x = 0; x < l_nCopyWidth; x++)
                    {
                        l_pDest[iDA] = l_pSrc[iSA];
                        l_pDest[iDR] = l_pSrc[iSR];
                        l_pDest[iDG] = l_pSrc[iSG];
                        l_pDest[iDB] = l_pSrc[iSB];
                        l_pDest += 4;
                        l_pSrc += 4;
                    }
                }
                else
                {
                    RETURN_ERROR(ERR_NOT_SUPPORTED);
                }
            }
 
            l_pSrcLine += psSrcBitmapFormat->nBytesPerLine;
 
            if (bVFlip)
            {
                l_pDestLine -= psDestBitmapFormat->nBytesPerLine;
            }
            else
            {
                l_pDestLine += psDestBitmapFormat->nBytesPerLine;
            }
        }
 
        RETURN_NOERROR;
    }
 
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)
    {
        if (this == &oImage)
        {
            return *this;
        }
        Create(oImage.m_sFormat.nWidth, oImage.m_sFormat.nHeight, oImage.m_sFormat.nBitsPerPixel,
               oImage.m_sFormat.nBytesPerLine, oImage.GetBitmap(), oImage.m_sFormat.nPixelFormat);
        return *this;
    }
 
public:
    static int32_t GetNextPowerOfTwo(int32_t const a)
    {
        // if a <= 0, 1 will be returned
        int32_t rval = (a > 0) ? a - 1 : 0; // if a <= 0, rval is 0, otherwise rval = a-1
        rval |= rval >> 1;
        rval |= rval >> 2;
        rval |= rval >> 4;
        rval |= rval >> 8;
        rval |= rval >> 16;
        return ++rval;
    }
 
    static int32_t CalcBitsPerPixelFromPixelFormat(int32_t const oPixelFormat)
    {
        switch (oPixelFormat)
        {
            case IImage::PF_8BIT: return 8;
            case IImage::PF_GREYSCALE_8: return 8; 
            case IImage::PF_RGB_8: return 8; 
            case IImage::PF_16BIT:
                return 16; 
            case IImage::PF_GREYSCALE_10: return 16; 
            case IImage::PF_GREYSCALE_12: return 16; 
            case IImage::PF_GREYSCALE_14: return 16; 
            case IImage::PF_GREYSCALE_16: return 16; 
            case IImage::PF_RGB_444: return 16; 
            case IImage::PF_RGB_565: return 16; 
            case IImage::PF_RGBA_4444:
                return 16; 
            case IImage::PF_RGB_555:
                return 16; 
            case IImage::PF_RGBA_5551: return 16;
            case IImage::PF_ABGR_4444:
                return 16; 
            case IImage::PF_ABGR_1555: return 16;
            case IImage::PF_RIII_10: return 16;
            case IImage::PF_RIII_12: return 16;
            case IImage::PF_RIII_14: return 16;
            case IImage::PF_RIII_16: return 16;
            case IImage::PF_BGR_565: return 16;
            case IImage::PF_BGR_555: return 16;
            case IImage::PF_BGRA_5551: return 16;
            case IImage::PF_ARGB_1555: return 16;
            case IImage::PF_24BIT:
                return 24; 
            case IImage::PF_GREYSCALE_18: return 24;
            case IImage::PF_GREYSCALE_20: return 24;
            case IImage::PF_GREYSCALE_22: return 24;
            case IImage::PF_GREYSCALE_24: return 24; 
            case IImage::PF_RGB_888:
                return 24; 
            case IImage::PF_BGR_888: return 24; 
            case IImage::PF_32BIT:
                return 32; 
            case IImage::PF_ARGB_8888:
                return 32; 
            case IImage::PF_ABGR_8888:
                return 32; 
            case IImage::PF_RGBA_8888:
                return 32; 
            case IImage::PF_BGRA_8888:
                return 32; 
            case IImage::PF_xRGB_8888:
                return 32; 
            case IImage::PF_xBGR_8888:
                return 32; 
            case IImage::PF_RGBx_8888:
                return 32; 
            case IImage::PF_BGRx_8888:
                return 32; 
            case IImage::PF_GREYSCALE_32: return 32; 
            case IImage::PF_GREYSCALE_FLOAT32: return 32; 
            case IImage::PF_YUV420P_888:
                return 24; 
            default: return 0;
        }
    }
 
    static bool NeedAlphaBlend(int32_t const oPixelFormat)
    {
        switch (oPixelFormat)
        {
            case IImage::PF_RGBA_4444:
                return true; 
            case IImage::PF_ABGR_4444:
                return true; 
            case IImage::PF_ARGB_1555: return true;
            case IImage::PF_RGBA_5551: return true;
            case IImage::PF_ABGR_1555: return true;
            case IImage::PF_BGRA_5551: return true;
            case IImage::PF_32BIT:
                return true; 
            case IImage::PF_ARGB_8888:
                return true; 
            case IImage::PF_ABGR_8888:
                return true; 
            case IImage::PF_RGBA_8888:
                return true; 
            case IImage::PF_BGRA_8888:
                return true; 
            default: return false;
        }
    }
 
protected:
    inline void Yuv2Rgb(tUInt8 y, tUInt8 u, tUInt8 v, tUInt8* pPixel)
    {
        int32_t const c = y - 16;
        int32_t const d = u - 128;
        int32_t const e = v - 128;
        int32_t const r = (298 * c + 409 * e + 128) >> 8;
        int32_t const g = (298 * c - 100 * d - 208 * e + 128) >> 8;
        int32_t const b = (298 * c + 516 * d + 128) >> 8;
        pPixel[0] = static_cast<uint8_t>(std::clamp(r, 0, 255));
        pPixel[1] = static_cast<uint8_t>(std::clamp(g, 0, 255));
        pPixel[2] = static_cast<uint8_t>(std::clamp(b, 0, 255));
    }
 
    inline tUInt8 YFromRGB(tUInt8* pPixel)
    {
        return ((66 * pPixel[0] + 129 * pPixel[1] + 25 * pPixel[2] + 128) >> 8) + 16;
    }
 
    inline tUInt8 UFromRGB(tUInt8* pPixel)
    {
        return ((-38 * pPixel[0] - 74 * pPixel[1] + 112 * pPixel[2] + 128) >> 8) + 128;
    }
 
    inline tUInt8 VFromRGB(tUInt8* pPixel)
    {
        return ((112 * pPixel[0] - 94 * pPixel[1] - 18 * pPixel[2] + 128) >> 8) + 128;
    }
 
    static tUInt8 BlendPixel(tUInt8 c1, tUInt8 c2, tUInt8 c3, tUInt8 c4, tInt alpha_y, tInt alpha_x)
    {
        tInt a1 = alpha_x * alpha_y;
        tInt a2 = alpha_x * (256 - alpha_y);
        tInt a3 = (256 - alpha_x) * alpha_y;
        tInt a4 = (256 - alpha_x) * (256 - alpha_y);
 
        return (tUInt8) (((tInt) c1 * a1 + (tInt) c2 * a2 + (tInt) c3 * a3 + (tInt) c4 * a4) >> 16);
    }
 
    static tUInt32 BlendRGB32(tUInt32 c1, tUInt32 c2, tUInt32 c3, tUInt32 c4, tInt alpha_y, tInt alpha_x)
    {
        tInt a1 = alpha_x * alpha_y;
        tInt a2 = alpha_x * (256 - alpha_y);
        tInt a3 = (256 - alpha_x) * alpha_y;
        tInt a4 = (256 - alpha_x) * (256 - alpha_y);
 
        tUInt8* pb1 = (tUInt8*) &c1;
        tUInt8* pb2 = (tUInt8*) &c2;
        tUInt8* pb3 = (tUInt8*) &c3;
        tUInt8* pb4 = (tUInt8*) &c4;
 
        tUInt32 c = 0;
        tUInt8* pb = (tUInt8*) &c;
 
        pb[1] = (tUInt8) (((tInt) pb1[0] * a1 + (tInt) pb2[0] * a2 + (tInt) pb3[0] * a3 + (tInt) pb4[0] * a4) >> 16);
        pb[2] = (tUInt8) (((tInt) pb1[1] * a1 + (tInt) pb2[1] * a2 + (tInt) pb3[1] * a3 + (tInt) pb4[1] * a4) >> 16);
        pb[3] = (tUInt8) (((tInt) pb1[2] * a1 + (tInt) pb2[2] * a2 + (tInt) pb3[2] * a3 + (tInt) pb4[2] * a4) >> 16);
        pb[0] = (tUInt8) (((tInt) pb1[3] * a1 + (tInt) pb2[3] * a2 + (tInt) pb3[3] * a3 + (tInt) pb4[3] * a4) >> 16);
 
        return c;
    }
 
    static tUInt16 AdjustMasks(tUInt16 iSMask, tUInt16 iDMask, tInt& iPos)
    {
        if (iSMask == 0 || iDMask == 0)
        {
            return 0;
        }
 
        if (iSMask == iDMask)
        {
            return iDMask;
        }
 
        while (iSMask > iDMask)
        {
            iSMask >>= 1;
            iPos++;
        }
 
        tInt iMoveCount = 0;
        while ((iSMask | (iSMask - 1)) < iDMask)
        {
            iSMask <<= 1;
            iPos--;
            iMoveCount++;
        }
        return (iDMask >> iMoveCount) << iMoveCount;
    }
};
 
inline tInt cImage::m_nDefaultLineAlignment = 4;
inline tInt cImage::m_nDefaultMemoryAlignment = 16;
 
} // namespace dengar
 
using dengar::cImage;
} // namespace graphicslib
 
} // namespace disptb
 
} // namespace adtf