TAPsBitmapImageHandler.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsBitmapImageHandler.hpp

Bitmap Image Handler
Adapted from OpenGL Game Programming book (2001)

SUKITTI PUNAK   (09/16/2004)
UPDATE          (07/17/2007)
******************************************************************************/
#ifndef TAPs_BITMAP_IMAGE_HANDLER_HPP
#define TAPs_BITMAP_IMAGE_HANDLER_HPP

#include <iostream>
using std::cerr;

#if !defined( _WINDOWS ) && !defined( WIN32 )
    #include "TAPsWindowsDataTypeDef.hpp"
    using namespace TAPs::WindowsDataTypeDef;
#else
    #include <windows.h>
#endif

#include "../Core/TAPsDef.hpp"

// Uncomment the following #define line for Debug Message
#define BITMAPIMAGE_H_DEBUG_MODE
#ifdef BITMAPIMAGE_H_DEBUG_MODE
    #define BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( s ) { printf( "DEBUG MESSAGE: " ); printf s; }
#else
    #define BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( s ) {}
#endif

BEGIN_NAMESPACE_TAPs
//=============================================================================
// CLASS:   BitmapImage
// DESC:  Handle a bitmap data.
class BitmapImage {
//******************************************************************************
// Bitmap File Header
typedef struct tagBITMAPFILEHEADER {
    WORD    bfType;         // specifies the file type; must be BM (0x4D42)
    DWORD   bfSize;         // specifies the size in bytes of the bitmap file
    WORD    bfReserved1;    // reserved: must be zero
    WORD    bfReserved2;    // reserved: must be zero
    DWORD   bfOffBits;      // specifies the offset, in bytes, from the
                            //   BITMAPFILEHEADER structure to the bitmap bits
} BITMAPFILEHEADER;
//******************************************************************************
// Bitmap Information Header
typedef struct tagBITMAPINFOHEADER {
    DWORD   biSize;             // specifies number of bytes required by the structure
    LONG    biWidth;            // specifies the width of the bitmap, in pixels
    LONG    biHeight;           // specifies the height of the bitmap, in pixels
    WORD    biPlanes;           // specifies the number of color planes, must be 1
    WORD    biBitCount;         // specifies the number of bits per pixel; must be 1, 4, 8, 16, 24, or 32
    DWORD   biCompression;      // specifies the type of compression
    DWORD   biSizeImage;        // size of image in bytes
    LONG    biXPelsPerMeter;    // specifies the number of pixels per meter in x axis
    LONG    biYPelsPerMeter;    // specifies the number of pixels per meter in y axis
    DWORD   biClrUsed;          // specifies the number of colors used by the bitmap
    DWORD   biClrImportant;     // specifies the number of colors that are important
} BITMAPINFOHEADER;
//******************************************************************************
// Member Functions
public:
    // START:   Constructor  ---------------------------------------------------
    BitmapImage()
    {
        m_pucBitmapImage = NULL;
    } // END:   Constructor


    // START:   Destructor  ----------------------------------------------------
    ~BitmapImage()
    {
        // reclaim the allocated memory if any
        if ( m_pucBitmapImage != NULL ) {
            delete [] m_pucBitmapImage;
            m_pucBitmapImage = NULL;
        }
    } // END:   Destructor


    // MEMBER FUNCION:  LoadBitMapFile()  --------------------------------------
    // DESC:
    bool LoadBitmapFile( char *pcFileName )
    {
        FILE                *filePtr;           // the file pointer
        BITMAPFILEHEADER    bitmapFileHeader;   // bitmap file header
        unsigned int        uiImageIdx = 0;     // image index counter
        unsigned char       ucTempRGB;          // swap variable

        // reclaim the allocated memory if any
        if ( m_pucBitmapImage != NULL ) {
            BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("Erase an old BMP image data\n") );
            delete [] m_pucBitmapImage;
            m_pucBitmapImage = NULL;
        }

        // try to open filename in "read binary" mode
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("sizeof(WORD)             = %d\n", sizeof(WORD)) );
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("sizeof(DWORD)            = %d\n", sizeof(DWORD)) );
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("sizeof(BITMAPFILEHEADER) = %d\n", sizeof(BITMAPFILEHEADER)) );
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("sizeof(BITMAPINFOHEADER) = %d\n", sizeof(BITMAPINFOHEADER)) );

        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("FileName = %s\n", pcFileName) );
        if ( ( filePtr = fopen( pcFileName, "rb" ) ) == NULL ) {
            BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("unsucceed opening the BMP image file\n") );
            return false;
        }
        else {
            BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("succeed opening the BMP image file\n") );
        }

        // read the bitmap file header
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("Read the BMP image file header\n") );
        //return false;
        //fread( &bitmapFileHeader, sizeof( BITMAPFILEHEADER ), 1, filePtr );
        fread( &bitmapFileHeader.bfType, sizeof( WORD ), 1, filePtr );
        fread( &bitmapFileHeader.bfSize, sizeof( DWORD ), 1, filePtr );
        fread( &bitmapFileHeader.bfReserved1, sizeof( WORD ), 1, filePtr );
        fread( &bitmapFileHeader.bfReserved2, sizeof( WORD ), 1, filePtr );
        fread( &bitmapFileHeader.bfOffBits, sizeof( DWORD ), 1, filePtr );
                
        // verify that this is a bitmap by checking for the universal bitmap id
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("Check whether the BMP image is a bitmap image\n") );
        
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("bfType = %d and SM_BITMAP_ID = %d\n", bitmapFileHeader.bfType, SM_BITMAP_ID) );
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("bfSize = %d\n", bitmapFileHeader.bfSize) );
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("bfOffbits = %d\n", bitmapFileHeader.bfOffBits) );
        if ( bitmapFileHeader.bfType != SM_BITMAP_ID ) {
            BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("No, it's not!\n") );
            fclose( filePtr );
            return false;
        }
        else {
            BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("Yes, it is.\n") );
        }

        fseek( filePtr, 14, SEEK_SET );

        // read the bitmap information header
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("Read bitmap info header\n") );

        fread( &m_pBitmapInfoHeader_st, sizeof( BITMAPINFOHEADER ), 1, filePtr );


        // HACK
        m_pBitmapInfoHeader_st.biSizeImage = m_pBitmapInfoHeader_st.biWidth * m_pBitmapInfoHeader_st.biHeight * 3;

        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("biSize          = %d\n", m_pBitmapInfoHeader_st.biSize) );
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("biWidth         = %d\n", m_pBitmapInfoHeader_st.biWidth) );
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("biHeight        = %d\n", m_pBitmapInfoHeader_st.biHeight) );
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("biPlanes        = %d\n", m_pBitmapInfoHeader_st.biPlanes) );
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("biBitCount      = %d\n", m_pBitmapInfoHeader_st.biBitCount) );
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("biCompression   = %d\n", m_pBitmapInfoHeader_st.biCompression) );
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("biSizeImage     = %d\n", m_pBitmapInfoHeader_st.biSizeImage) );
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("biXPelsPerMeter = %d\n", m_pBitmapInfoHeader_st.biXPelsPerMeter) );
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("biYPelsPerMeter = %d\n", m_pBitmapInfoHeader_st.biYPelsPerMeter) );
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("biClrUsed       = %d\n", m_pBitmapInfoHeader_st.biClrUsed) );
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("biClrImportant  = %d\n", m_pBitmapInfoHeader_st.biClrImportant) );

        // move file pointer to beginning of bitmap data
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("Go to the start of data\n") );
        fseek( filePtr, bitmapFileHeader.bfOffBits, SEEK_SET );

        // allocate enough memory for the bitmap image data
        m_pucBitmapImage = new unsigned char[ m_pBitmapInfoHeader_st.biSizeImage ];

        // verify memory allocation
        if ( !m_pucBitmapImage ) {
            BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("Couldn't allocate memory for the texture\n") );
            fclose( filePtr );
            return false;
        }
        else {
            BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("memory allocated for the texture, move on\n") );
        }

        // read in the bitmap image data
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("Read bitmap pixel data\n") );
        fread( m_pucBitmapImage, 1, m_pBitmapInfoHeader_st.biSizeImage, filePtr );

        // make sure bitmap image data was read
        //if ( !m_pucBitmapImage ) {
        //  fclose( filePtr );
        //  return false;
        //}

        // swap the R and B values to get RGB since the bitmap color format is 
        // in BGR
        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("Change BGR to RGB\n") );
        for ( uiImageIdx = 0; uiImageIdx < m_pBitmapInfoHeader_st.biSizeImage; uiImageIdx += 3 ) {
            ucTempRGB = m_pucBitmapImage[ uiImageIdx ];
            m_pucBitmapImage[ uiImageIdx ]     = m_pucBitmapImage[ uiImageIdx + 2 ];
            m_pucBitmapImage[ uiImageIdx + 2 ] = ucTempRGB;
        }

        // close the file
        fclose( filePtr );

        BITMAPIMAGE_H_DEBUG_MODE_BY_PRINTF( ("Done image loading\n") );
        return true;        // successful loading
    } // END:   LoadBitMapFile()

    //-------------------------------------------------------------------------
    // MEMBER FUNCTION: GetImageSize()
    // DESC:
    unsigned int GetWidth() const {
        return static_cast<unsigned int>( m_pBitmapInfoHeader_st.biHeight );
        //return m_ucWidth;
    } // END:   GetWidth()
    //-------------------------------------------------------------------------
    // MEMBER FUNCTION: GetImageSize()
    // DESC:
    unsigned int GetHeight() const {
        //return m_ucHeight;
        return static_cast<unsigned int>( m_pBitmapInfoHeader_st.biHeight );
    } // END:   GetHeight()
    //-------------------------------------------------------------------------
    // MEMBER FUNCTION: GetImageSize()
    // DESC:
    unsigned int GetImageSize() const {
        return  static_cast<unsigned int>( m_pBitmapInfoHeader_st.biSizeImage );
    } // END:   GetImageSize()
    //-------------------------------------------------------------------------
    // MEMBER FUNCTION: GetConstPtrToImageData()
    // DESC:
    unsigned char * const GetConstPtrToImageData() const {
        return m_pucBitmapImage;
    } // END:   GetConstPtrToImageData()
    //-------------------------------------------------------------------------
    // MEMBER FUNCTION: Available()
    // DESC:
    bool Available() const {
        return m_pucBitmapImage != NULL ? true : false;
    } // END:   Available()
    //-------------------------------------------------------------------------

//******************************************************************************
// Data Members
private:
    static const WORD SM_BITMAP_ID;
private:
    BITMAPINFOHEADER m_pBitmapInfoHeader_st;    // a pointer to the image info header
    unsigned char *m_pucBitmapImage;            // a pointer to the image data
    //unsigned char m_ucWidth;                  // image width
    //unsigned char m_ucHeight;                 // image height
}; // END CLASS BitmapImage
//-----------------------------------------------------------------------------
//=============================================================================
END_NAMESPACE_TAPs
//-----------------------------------------------------------------------------
// Include definition if TAPs_USE_EXPORT is not defined
#if !defined( TAPs_USE_EXPORT )
    #include "TAPsBitmapImageHandler.cpp"
#endif
//-----------------------------------------------------------------------------
#endif
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8