---

DIBitmap.cpp

Go to the documentation of this file.

// DIBitmap.cpp: implementation of the DIBitmap class.


#include "stdafx.h"
#include "DIBitmap.h"

// Construction/Destruction

DIBitmap::DIBitmap()
{
    assignedMemory = NULL;
    bmInfoHeader = NULL;
    RGBQuads = NULL;
    imageBytes = NULL;
}

DIBitmap::DIBitmap(const DIBitmap &copy)
{
    assignedMemory = NULL;
    bmInfoHeader = NULL;
    RGBQuads = NULL;
    imageBytes = NULL;

    set(copy);
}

DIBitmap::~DIBitmap()
{
    clear();
}

// Member functions

bool DIBitmap::loadFile(PCTSTR fName)
{
    BITMAPFILEHEADER filehdr;
    BITMAPINFOHEADER infohdr;
    DWORD infoHeaderSize, noBytesRead = 0;

    HANDLE hFile = INVALID_HANDLE_VALUE;
    void* ptr = NULL;
    BOOL isOk = true; 
    bool status = false;

    // This SEH ensures that handles are released but doesn't catch exceptions
    __try {
        if( fName == NULL )
            __leave;

        hFile = CreateFile(fName, 
            GENERIC_READ, FILE_SHARE_READ, NULL, 
            OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
        
        isOk = ReadFile(hFile, &filehdr, sizeof(BITMAPFILEHEADER), &noBytesRead, NULL);
        if( !isOk || (noBytesRead == 0) )
            __leave;

        if( 0x4d42 != filehdr.bfType )
            __leave;

        isOk = ReadFile(hFile, &infoHeaderSize, sizeof(DWORD), &noBytesRead, NULL);
        if( !isOk || (noBytesRead == 0) )
            __leave;
    
        infohdr.biSize = sizeof(BITMAPINFOHEADER);

        switch(infoHeaderSize){
#if WINVER >= 0x0500
        case sizeof(BITMAPV5HEADER):
            ptr = new BITMAPV5HEADER;
    
            isOk = ReadFile(hFile, (BYTE*)ptr + sizeof(DWORD), 
                sizeof(BITMAPV5HEADER) - sizeof(DWORD), &noBytesRead, NULL);
            if( !isOk || (noBytesRead == 0) )
                __leave;

            infohdr.biBitCount = ((PBITMAPV5HEADER)ptr)->bV5BitCount;
            infohdr.biClrImportant = ((PBITMAPV5HEADER)ptr)->bV5ClrImportant;
            infohdr.biClrUsed = ((PBITMAPV5HEADER)ptr)->bV5ClrUsed;
            infohdr.biCompression = ((PBITMAPV5HEADER)ptr)->bV5Compression;
            infohdr.biHeight = ((PBITMAPV5HEADER)ptr)->bV5Height;
            infohdr.biPlanes = ((PBITMAPV5HEADER)ptr)->bV5Planes;
            infohdr.biSizeImage = ((PBITMAPV5HEADER)ptr)->bV5SizeImage;
            infohdr.biWidth = ((PBITMAPV5HEADER)ptr)->bV5Width;
            infohdr.biXPelsPerMeter = ((PBITMAPV5HEADER)ptr)->bV5XPelsPerMeter;
            infohdr.biYPelsPerMeter = ((PBITMAPV5HEADER)ptr)->bV5YPelsPerMeter;
            break;
#endif
#if ((WINVER >= 0x0400) && (_WIN32_WINNT >= 0x0400))
        case sizeof(BITMAPV4HEADER):
            ptr = new BITMAPV4HEADER;
            
            isOk = ReadFile(hFile, (BYTE*)ptr + sizeof(DWORD), 
                sizeof(BITMAPV4HEADER) - sizeof(DWORD), &noBytesRead, NULL);
            if( !isOk || (noBytesRead == 0) )
                __leave;
            
            infohdr.biBitCount = ((PBITMAPV4HEADER)ptr)->bV4BitCount;
            infohdr.biClrImportant = ((PBITMAPV4HEADER)ptr)->bV4ClrImportant;
            infohdr.biClrUsed = ((PBITMAPV4HEADER)ptr)->bV4ClrUsed;
            infohdr.biCompression = ((PBITMAPV4HEADER)ptr)->bV4V4Compression;
            infohdr.biHeight = ((PBITMAPV4HEADER)ptr)->bV4Height;
            infohdr.biPlanes = ((PBITMAPV4HEADER)ptr)->bV4Planes;
            infohdr.biSizeImage = ((PBITMAPV4HEADER)ptr)->bV4SizeImage;
            infohdr.biWidth = ((PBITMAPV4HEADER)ptr)->bV4Width;
            infohdr.biXPelsPerMeter = ((PBITMAPV4HEADER)ptr)->bV4XPelsPerMeter;
            infohdr.biYPelsPerMeter = ((PBITMAPV4HEADER)ptr)->bV4YPelsPerMeter;
            break;
#endif
        case sizeof(BITMAPINFOHEADER):
            isOk = ReadFile(hFile, (BYTE*)(&infohdr) + sizeof(DWORD), 
                sizeof(BITMAPINFOHEADER) - sizeof(DWORD), &noBytesRead, NULL);
            if( !isOk || (noBytesRead == 0) )
                __leave;
            break;
        default:
            __leave;
        }
        
        if(!imageMemAlloc(&infohdr))
            __leave;

        if(bmInfoHeader->biClrUsed != 0){
            isOk = ReadFile(hFile, RGBQuads, 
                sizeof(RGBQUAD) * bmInfoHeader->biClrUsed, &noBytesRead, NULL);
            if( !isOk || (noBytesRead == 0) )
                __leave;
        }

        isOk = ReadFile(hFile, imageBytes, bmInfoHeader->biSizeImage, 
            &noBytesRead, NULL);
        if( !isOk )
                __leave;

        status = true;
    }
    __finally {
        if(hFile != INVALID_HANDLE_VALUE)
            CloseHandle(hFile);
        if(ptr != NULL)
            delete ptr;
    }

    return status;
}

bool DIBitmap::saveFile(PCTSTR fName, const DWORD disposition) const
{   
    BITMAPFILEHEADER filehdr;
    DWORD noBytesWritten, offBits, sizeLessFileHdr;
    
    HANDLE hFile = INVALID_HANDLE_VALUE;
    bool status = false;
    BOOL isOk = true;

    // SEH ensures that handles are released but doesn't catch exceptions
    __try {
        if( fName == NULL || assignedMemory == NULL)
            __leave;

        if( !(disposition == CREATE_NEW || disposition == CREATE_ALWAYS 
            || disposition == TRUNCATE_EXISTING) )
            __leave;

        hFile = CreateFile(fName, 
            GENERIC_WRITE, 0,NULL, 
            disposition, FILE_ATTRIBUTE_NORMAL, NULL);
            
        if(hFile == INVALID_HANDLE_VALUE)
            __leave;
        
        offBits = sizeof(BITMAPINFOHEADER) + (bmInfoHeader->biClrUsed * sizeof(RGBQUAD));
        sizeLessFileHdr = offBits + bmInfoHeader->biSizeImage;

        filehdr.bfType = (WORD) 0x4d42;        
        filehdr.bfSize = (DWORD) (sizeLessFileHdr + sizeof(BITMAPFILEHEADER));
        filehdr.bfReserved1 = 0;
        filehdr.bfReserved2 = 0;
        filehdr.bfOffBits = (DWORD) (sizeof(BITMAPFILEHEADER) + offBits);

        isOk = WriteFile(hFile, &filehdr, sizeof(BITMAPFILEHEADER), &noBytesWritten, NULL);
        if( !isOk || (noBytesWritten != sizeof(BITMAPFILEHEADER)) ){
            isOk = false;
            __leave;
        }

        isOk = WriteFile(hFile, bmInfoHeader, sizeLessFileHdr, &noBytesWritten, NULL);
        if( !isOk || (noBytesWritten != sizeLessFileHdr) ){
            isOk = false;
            __leave;
        }

        status = true;
    }
    __finally {
        if(hFile != INVALID_HANDLE_VALUE)
            CloseHandle(hFile);

        // If file can not be written correctly then delete it
        // Only needs to happens if a new file/truncated file 
        // has been correctly created
        if(!isOk)
            DeleteFile(fName);
    }

    return status;
}

bool DIBitmap::imageMemAlloc(const PBITMAPINFOHEADER infoHeader)
{
    if(infoHeader == bmInfoHeader || infoHeader == NULL)
        return false;

    if(!isCompatibleBitmap(infoHeader))
        return false;

    // Calculate the image size (if it's not given).
    DWORD sizeImage;
    if( 0 == infoHeader->biSizeImage ){
        // The image size hasn't been supplied the following calculates how large 
        // an image with the given width, height and bitcount is.
        
        // ((((width * bitcount) + 31) bitwiseAND -31) SHIFTLEFT 3) * absolute(height)
        sizeImage =
            (((( infoHeader->biWidth * infoHeader->biBitCount ) + 31) & ~31) >> 3) 
                * abs(infoHeader->biHeight);
    } else {
        sizeImage = infoHeader->biSizeImage;
    }

    // Calculate the number of colours used (if not specified)
    DWORD clrUsed;
    if( 0 == infoHeader->biClrUsed ) {
        if(infoHeader->biCompression == BI_BITFIELDS) {
            clrUsed = 3;
        } else {
            switch(infoHeader->biBitCount){
            case 32:
            case 24:
            case 16:
                clrUsed = 0;
                break;
            case 8:
            case 4:
            case 1:
                // shifts 1 right by the bitcount
                // ie 1 << 8 = 256
                //    1 << 4 = 32
                //    1 << 1 = 2
                clrUsed = 1 << infoHeader->biBitCount;
                break;
            default:
                // This should never happen since isCompatibleBitmap() passed the header
                clrUsed = 0;
                break;
            }
        }
    }
    else
        clrUsed = infoHeader->biClrUsed;

    int paletteBytes = sizeof(RGBQUAD) * clrUsed;
    int totalBytes = sizeof(BITMAPINFOHEADER) + paletteBytes + sizeImage;

    // If the current allocated memory is different from the required allocation.
    // There are times when reallocation occurs unnecessarily, there is little point
    // mudding this check to catch these though.
    if( bmInfoHeader == NULL 
        || bmInfoHeader->biSize != sizeImage 
        || bmInfoHeader->biClrUsed != clrUsed){

        imageMemDealloc();

        // The new opperator could be replaced with a windows stack function
        // providing that imageMemDealloc is also adjusted
        assignedMemory = new BYTE[totalBytes];
        if(assignedMemory == NULL)
            return false;
    }
    
    // A windows function which does what the name suggests
    // The purpose is to ensure that padding is zeroed (as it is not normally set 
    // anywhere else).
    ZeroMemory(assignedMemory, totalBytes);
    
    bmInfoHeader = (BITMAPINFOHEADER*)assignedMemory;
    if(paletteBytes != 0)
        RGBQuads = (RGBQUAD*)(assignedMemory + sizeof(BITMAPINFOHEADER));
    else
        RGBQuads = NULL;
    imageBytes = assignedMemory + paletteBytes + sizeof(BITMAPINFOHEADER);
    
    // Windows copy function
    CopyMemory(bmInfoHeader, (BYTE*)infoHeader, sizeof(BITMAPINFOHEADER));

    bmInfoHeader->biSizeImage = sizeImage;
    bmInfoHeader->biClrUsed = clrUsed;

    return true;
}


DIBitmap::imageMemDealloc()
{
    if(assignedMemory != NULL){
        delete [] assignedMemory;
        assignedMemory = NULL;
        bmInfoHeader = NULL;
        RGBQuads = NULL;
        imageBytes = NULL; 
    }
}

bool DIBitmap::set(const PBITMAPINFO dib)
{
    bool rtrn= false;

    if( dib == NULL )
        return false;
    if( (PBITMAPINFOHEADER)dib == bmInfoHeader )
        return true;

    __try {
        if( !imageMemAlloc((PBITMAPINFOHEADER)dib) )
            __leave;
        
        int size = (sizeof(RGBQUAD) * bmInfoHeader->biClrUsed) + bmInfoHeader->biSizeImage;
        CopyMemory( (BYTE*) bmInfoHeader + sizeof(BITMAPINFOHEADER), 
            (BYTE*) dib + sizeof(BITMAPINFOHEADER), size );
        rtrn = true;
    }
    __except( (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION) 
            ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        clear();
    }

    return rtrn;
}


bool DIBitmap::createCompatible(const int width, const int height, const int bits)
{
    // sanity checks are performed with a call to isCompatibleBitmap from imageMemAlloc
    
    BITMAPINFOHEADER tempHdr;

    tempHdr.biSize = sizeof(BITMAPINFOHEADER); 
    tempHdr.biWidth = width; 
    tempHdr.biHeight = height; 
    tempHdr.biPlanes = 1; 
    tempHdr.biBitCount = bits; 
    tempHdr.biCompression = BI_RGB; 
    tempHdr.biSizeImage = 0; 
    tempHdr.biXPelsPerMeter = 0; 
    tempHdr.biYPelsPerMeter = 0; 
    tempHdr.biClrUsed = 0; 
    tempHdr.biClrImportant = 0; 

    return imageMemAlloc(&tempHdr);
}


const DIBitmap &DIBitmap::operator=(const DIBitmap& right)
{
    // Check for self assignement
    if(&right != this) {
        clear();
        if( right.getPBITMAPINFOHEADER() != NULL ){
            set(right);
        }
    }

    return *this;
}

bool DIBitmap::isCompatibleBitmap(const PBITMAPINFOHEADER ptrHeader)
{
    if(ptrHeader == NULL)
        return false;
    
    if(ptrHeader->biSize != sizeof(BITMAPINFOHEADER))
        return false;
    if(ptrHeader->biWidth < 1)
        return false;
    if(ptrHeader->biPlanes != 1)
        return false;
    if(ptrHeader->biSizeImage < 0)
        return false;
    if(ptrHeader->biXPelsPerMeter < 0)
        return false;
    if(ptrHeader->biYPelsPerMeter < 0)
        return false;
    if(ptrHeader->biClrUsed < 0  || ptrHeader->biClrUsed > 256)
        return false;
    if(ptrHeader->biClrImportant < 0 || ptrHeader->biClrImportant > 256)
        return false;

    switch(ptrHeader->biCompression){
    case BI_RLE8:
        if(ptrHeader->biHeight < 1)
            return false;
        if(ptrHeader->biBitCount == 8)
            return true;
        else
            return false;
    case BI_RLE4:
        if(ptrHeader->biHeight < 1)
            return false;
        if(ptrHeader->biBitCount == 4)
            return true;
        else
            return false;
    case BI_BITFIELDS:
        if(ptrHeader->biHeight == 0)
            return false;
        if(ptrHeader->biBitCount == 24 || ptrHeader->biBitCount == 32)
            return true;
        else
            return false;
    case BI_RGB:
        if(ptrHeader->biHeight == 0)
            return false;
        switch(ptrHeader->biBitCount){
        case 32:
        case 24:
        case 16:
        case 8:
        case 4:
        case 1:
            return true;
        default:
            return false;
        }
    default:
        return false;
    }
    // function has already returned by this point
}

---