cSurfaceInfo.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cSurfaceInfo_H
#define _INC_cSurfaceInfo_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "../WinAPI/WinTypes.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cMem.h"
#include "GrayCore/include/cBits.h"
 
namespace GrayLib
{
        typedef int PIXELS_t;           
        typedef BYTE COLOR_ELEM_t;      
 
        enum SURF_FORM_TYPE
        {
 
                SURF_FORM_UNKNOWN = 0,          
                SURF_FORM_RGB888 = 20,          
 
                SURF_FORM_ARGB8888 = 21,        
                SURF_FORM_XRGB8888 = 22,        
 
                SURF_FORM_RGB565 = 23,          
                SURF_FORM_XRGB1555 = 24,        
 
                SURF_FORM_ARGB1555 = 25,        
                SURF_FORM_A8 = 28,                      
 
                SURF_FORM_BGR888 = 31,          
                SURF_FORM_ABGR8888 = 32,        
                SURF_FORM_XBGR8888 = 33,        
 
                SURF_FORM_D32 = 71,             
                SURF_FORM_D16 = 80,             
                SURF_FORM_R32F = 114,   
 
                SURF_FORM_A1 = 118,     
 
#if 0
                // Special DirectX compressed formats. just leave these as compressed. no pixel access.
                D3DFMT_DXT1 = MAKEFOURCC('D', 'X', 'T', '1'),
                D3DFMT_DXT2 = MAKEFOURCC('D', 'X', 'T', '2'),
                D3DFMT_DXT3 = MAKEFOURCC('D', 'X', 'T', '3'),
                D3DFMT_DXT4 = MAKEFOURCC('D', 'X', 'T', '4'),
                D3DFMT_DXT5 = MAKEFOURCC('D', 'X', 'T', '5'),
#endif
 
                SURF_FORM_QTY,
        };
 
#ifdef __linux__
#pragma pack(push,1)
        struct CATTR_PACKED tagBITMAPINFOHEADER
        {
                UINT32      biSize;
                INT32       biWidth;
                INT32       biHeight;
                WORD       biPlanes;
                WORD       biBitCount;
                UINT32      biCompression;
                UINT32      biSizeImage;
                INT32       biXPelsPerMeter;
                INT32       biYPelsPerMeter;
                UINT32      biClrUsed;
                UINT32      biClrImportant;
        };
        struct CATTR_PACKED tagRGBQUAD
        {
                BYTE    rgbBlue;
                BYTE    rgbGreen;
                BYTE    rgbRed;
                BYTE    rgbReserved;
        };
        struct CATTR_PACKED tagBITMAPINFO
        {
                tagBITMAPINFOHEADER bmiHeader;
                tagRGBQUAD             bmiColors[1];
        };
        enum BI_TYPE
        {
                BI_RGB = 0,
                BI_RLE8 = 1,
                BI_RLE4 = 2,
                BI_BITFIELDS = 3,
                BI_JPEG = 4,
                BI_PNG = 5,
        };
#pragma pack(pop)
#endif
 
        class cSurfaceBitmapInfo;
 
        class GRAYLIB_LINK cSurfaceInfo
        {
 
        private:
                cWinSize m_Size;                        
                size_t m_uPitchBytes;           
                SURF_FORM_TYPE m_ePixelFormat;  
 
        public:
                static const PIXELS_t kMaxX = 8 * 1024; // Arbitrary Max reasonable value.
                static const PIXELS_t kMaxY = 8 * 1024; // Arbitrary Max reasonable value.
 
        public:
                cSurfaceInfo(PIXELS_t cx = 0, PIXELS_t cy = 0, size_t uPitchBytes = 0, SURF_FORM_TYPE ePixelFormat = SURF_FORM_UNKNOWN)
                        : m_Size(cx, cy)
                        , m_uPitchBytes(uPitchBytes)
                        , m_ePixelFormat(ePixelFormat)
                {
                        ASSERT(isReasonableInfo());
                }
                cSurfaceInfo(const cSurfaceBitmapInfo* pBMI)
                {
                        this->SetBitmapInfo(pBMI);
                }
                cSurfaceInfo(struct tagBITMAPINFOHEADER* pBMI)
                {
                        SetBitmapInfo((const cSurfaceBitmapInfo*)pBMI);
                }
                cSurfaceInfo(const tagBITMAPINFO* pBMI)
                {
                        SetBitmapInfo((const cSurfaceBitmapInfo*)pBMI);
                }
#ifdef _WIN32
                cSurfaceInfo(const BITMAP& bm)
                {
                        SetBitmapInfo(bm);
                }
#endif
 
                PIXELS_t get_Width() const noexcept
                {
                        return m_Size.cx;
                }
                PIXELS_t get_Height() const noexcept
                {
                        return ABS(m_Size.cy);
                }
                PIXELS_t get_HeightRaw() const noexcept
                {
                        return m_Size.cy;
                }
                bool isTopDown() const noexcept
                {
                        return m_Size.cy >= 0;
                }
                cWinSize get_Size() const noexcept
                {
                        // Remove isTopDown info.
                        return cWinSize(m_Size.cx, get_Height());
                }
                size_t get_PitchBytes() const noexcept
                {
                        return m_uPitchBytes;
                }
                void put_PitchBytes(size_t uPitchBytes) noexcept
                {
                        m_uPitchBytes = uPitchBytes;
                }
 
                SURF_FORM_TYPE get_PixelFormat() const noexcept
                {
                        return m_ePixelFormat;
                }
                size_t get_SurfaceSize() const noexcept
                {
                        return get_Height() * get_PitchBytes();
                }
                BIT_SIZE_t get_BitsPerPixel() const noexcept
                {                       
                        return GetBitsPerPixel(m_ePixelFormat);
                }
                size_t get_BytesPerPixel() const noexcept
                {
                        // @note m_ePixelFormat = SURF_FORM_A1 not truly valid here. just returns 0.
                        return get_BitsPerPixel() / cBits::k_8;
                }
 
                bool isValidInfo() const noexcept
                {
                        const PIXELS_t cx = get_Height();
                        if (cx <= 0 || cx > kMaxX)
                                return false;
                        const PIXELS_t cy = get_Height();
                        if (cy <= 0 || cy > kMaxY)
                                return false;
                        if (m_uPitchBytes <= 0 || m_uPitchBytes > kMaxX * 4)
                                return false;
                        if (m_ePixelFormat <= SURF_FORM_UNKNOWN || m_ePixelFormat >= SURF_FORM_QTY)
                                return false;
                        return true;
                }
 
                bool isReasonableInfo() const noexcept
                {
                        if (m_Size.cx < 0 || m_Size.cx > kMaxX)
                                return false;
                        const PIXELS_t cy = get_Height();
                        if (cy < 0 || cy > kMaxY)
                                return false;
                        if (m_uPitchBytes > kMaxX * 4) // m_uPitchBytes < 0 not possible for unsigned of course.
                                return false;
                        if (m_ePixelFormat < SURF_FORM_UNKNOWN || m_ePixelFormat >= SURF_FORM_QTY)
                                return false;
                        return true;
                }
                bool IsEqual(const cSurfaceInfo& rInfo) const noexcept
                {
                        if (m_Size.cx != rInfo.m_Size.cx)
                                return false;
                        if (m_Size.cy != rInfo.m_Size.cy)
                                return false;
                        if (m_uPitchBytes != rInfo.m_uPitchBytes)
                                return false;
                        if (m_ePixelFormat != rInfo.m_ePixelFormat)
                                return false;
                        return true;
                }
 
                void SetSurfaceInfo(const cSurfaceInfo& rInfo)
                {
                        m_Size = rInfo.m_Size;
                        m_uPitchBytes = rInfo.m_uPitchBytes;
                        m_ePixelFormat = rInfo.m_ePixelFormat;
                        ASSERT(isReasonableInfo());
                }
                void InitSurfaceInfo(PIXELS_t cx = 0, PIXELS_t cy = 0, size_t uPitchBytes = 0, SURF_FORM_TYPE ePixelFormat = SURF_FORM_UNKNOWN) noexcept
                {
                        m_Size.cx = cx;
                        m_Size.cy = cy;
                        m_uPitchBytes = uPitchBytes;
                        m_ePixelFormat = ePixelFormat;
                        DEBUG_CHECK(isReasonableInfo());
                }
 
                static BIT_SIZE_t GRAYCALL GetBitsPerPixel(SURF_FORM_TYPE ePixelFormat) noexcept;
                static COLOR_ELEM_t GRAYCALL GetColorElements(SURF_FORM_TYPE ePixelFormat) noexcept;
                static SURF_FORM_TYPE GRAYCALL GetPixelFormat(int iBitsPerPixel, int iColorElements);
 
                static inline constexpr size_t CvtBitsToAlignedBytes(UINT nBitsTotal, size_t nAlignBytes) noexcept
                {
                        
                        const size_t nAlignBits = nAlignBytes * cBits::k_8;
                        return (((nBitsTotal + nAlignBits - 1) / nAlignBits) * nAlignBytes);
                }
                void InitAligned(PIXELS_t cx, PIXELS_t cy, size_t nAlignBytes, SURF_FORM_TYPE ePixelFormat)
                {
                        ASSERT(nAlignBytes > 0);
                        const BIT_SIZE_t uBitsPerPixel = GetBitsPerPixel(ePixelFormat);
                        ASSERT(uBitsPerPixel > 0);
                        InitSurfaceInfo(cx, cy, CvtBitsToAlignedBytes(cx * uBitsPerPixel, nAlignBytes), ePixelFormat);
                }
 
                void SetBitmapInfo(const cSurfaceBitmapInfo* pBMI);
                void SetBitmapInfo(const struct tagBITMAPINFOHEADER* pBMI)
                {
                        SetBitmapInfo((const cSurfaceBitmapInfo*)pBMI);
                }
                void SetBitmapInfo(const tagBITMAPINFO* pBMI)
                {
                        SetBitmapInfo((const cSurfaceBitmapInfo*)pBMI);
                }
#ifdef _WIN32
                void SetBitmapInfo(const BITMAP& bm);
#endif
        };
 
        class GRAYLIB_LINK cSurfaceBitmapInfo : public tagBITMAPINFO
        {
 
        public:
                cSurfaceBitmapInfo() noexcept
                {
                        InitZero();
                }
                cSurfaceBitmapInfo(const cSurfaceInfo& rInfo)
                {
                        SetSurfaceInfo(rInfo);
                }
 
                void InitZero() noexcept
                {
                        cMem::Zero(this, sizeof(*this));
                }
                bool isCompressed() const noexcept
                {
                        switch (this->bmiHeader.biCompression)
                        {
                        case BI_RGB:
                                return false;
                        default:
                                return true;    // everything else is considered compressed.
                        }
                }
                bool isValidInfo() const;
 
                PIXELS_t get_Width() const noexcept
                {
                        DEBUG_CHECK(this != nullptr);
                        return (PIXELS_t)this->bmiHeader.biWidth ;
                }
                PIXELS_t get_Height() const noexcept
                {
                        DEBUG_CHECK(this != nullptr);
                        return ABS((int)this->bmiHeader.biHeight) ;
                }
                PIXELS_t get_HeightRaw() const noexcept
                {
                        DEBUG_CHECK(this != nullptr);
                        return this->bmiHeader.biHeight;
                }
 
                void SetHeightTopDown() noexcept
                {
                        this->bmiHeader.biHeight = ABS(this->bmiHeader.biHeight);
                }
                bool isTopDown() const noexcept
                {
                        if (isCompressed())     // all compressed images don't do this bullshit.
                                return true;
                        if (this->bmiHeader.biHeight < 0)       // GDI marks these as negative.
                                return true;
                        return false;   // old fashion _WIN32 GDI bottom up mode.
                }
                BIT_SIZE_t get_BitsPerPixel() const noexcept
                {
                        DEBUG_CHECK(this != nullptr);
                        return((BIT_SIZE_t)this->bmiHeader.biBitCount * this->bmiHeader.biPlanes);
                }
 
                void SetSurfaceInfo(const cSurfaceInfo& rInfo);
                void SetCopy(const tagBITMAPINFO& rCopy);
 
                size_t get_PitchBytes() const;
                SURF_FORM_TYPE get_PixelFormat() const;
 
                WORD get_NumColors() const;
                size_t get_ColorSize() const noexcept
                {
                        return this->get_NumColors() * sizeof(tagRGBQUAD);
                }
                tagRGBQUAD* get_ColorTablePtr() const noexcept
                {
                        DEBUG_CHECK(this != nullptr);
                        return((tagRGBQUAD*)(((BYTE*)const_cast<cSurfaceBitmapInfo*>(this)) + this->bmiHeader.biSize));
                }
 
                size_t get_SurfaceSize() const noexcept;
                size_t get_ImageSize() const noexcept;
                size_t get_TotalSize() const noexcept;
 
                BYTE* get_PixelDataPtr() const;
        };
};
#endif // _INC_cSurfaceInfo_H