You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1007 lines
23 KiB
1007 lines
23 KiB
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1993.
|
|
//
|
|
// File: bmpfile.cxx
|
|
//
|
|
// Contents: CBitmapFile implementation
|
|
//
|
|
// Classes:
|
|
//
|
|
// Functions:
|
|
//
|
|
// History: 4-23-94 KirtD Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "headers.hxx"
|
|
#pragma hdrstop
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CBitmapFile::CBitmapFile
|
|
//
|
|
// Synopsis: Constructor
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns: nothing
|
|
//
|
|
// History: 4-23-94 KirtD Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
CBitmapFile::CBitmapFile ()
|
|
{
|
|
//
|
|
// Initialize private members
|
|
//
|
|
|
|
//
|
|
// The name
|
|
//
|
|
|
|
_pszBitmapFile[0] = '\0';
|
|
_cBitmapFile = 0;
|
|
|
|
//
|
|
// The bitmap information
|
|
//
|
|
|
|
_cbi = 0;
|
|
_pbi = NULL;
|
|
|
|
//
|
|
// The bits
|
|
//
|
|
|
|
_cbData = 0;
|
|
_pbData = NULL;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CBitmapFile::~CBitmapFile
|
|
//
|
|
// Synopsis: Destructor
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns: nothing
|
|
//
|
|
// History: 4-23-94 KirtD Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
CBitmapFile::~CBitmapFile ()
|
|
{
|
|
//
|
|
// Delete any possibly allocated things
|
|
//
|
|
|
|
delete _pbi;
|
|
delete _pbData;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CBitmapFile::LoadBitmapFile
|
|
//
|
|
// Synopsis: loads a bitmap file
|
|
//
|
|
// Arguments: [pszFile] -- the file
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
// History: 4-23-94 KirtD Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
CBitmapFile::LoadBitmapFile (LPSTR pszFile)
|
|
{
|
|
HRESULT hr = ResultFromScode(S_OK);
|
|
HANDLE hFile = INVALID_HANDLE_VALUE;
|
|
HANDLE hMap = INVALID_HANDLE_VALUE;
|
|
DWORD dwFileSizeLow = 0;
|
|
DWORD dwFileSizeHigh = 0;
|
|
LPBYTE pbuffer = NULL;
|
|
|
|
//
|
|
// First open the file
|
|
//
|
|
|
|
hFile = CreateFileA(pszFile,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
|
|
if (hFile == INVALID_HANDLE_VALUE)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
//
|
|
// Get the size of the file
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
dwFileSizeLow = GetFileSize(hFile, &dwFileSizeHigh);
|
|
if ((dwFileSizeLow == 0xFFFFFFFF) && (GetLastError() != NO_ERROR))
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
else if (dwFileSizeHigh != 0)
|
|
{
|
|
//
|
|
// Bitmap files can't be greater than 4G
|
|
//
|
|
|
|
hr = ResultFromScode(E_FAIL);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Create a file mapping object on the file
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hMap = CreateFileMapping(hFile,
|
|
NULL,
|
|
PAGE_READONLY,
|
|
0,
|
|
dwFileSizeLow,
|
|
NULL);
|
|
|
|
if (hMap == INVALID_HANDLE_VALUE)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now map a view of the file into our address space
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pbuffer = (LPBYTE)MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0);
|
|
if (pbuffer == NULL)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
}
|
|
|
|
//
|
|
// Get the bitmap data from the buffer
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _GetBitmapDataFromBuffer(pbuffer, (ULONG)dwFileSizeLow);
|
|
}
|
|
|
|
//
|
|
// Record the file name
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ULONG cFile;
|
|
|
|
//
|
|
// Get the length of the file name
|
|
//
|
|
|
|
cFile = strlen(pszFile);
|
|
|
|
//
|
|
// Check to see that our buffer is big enough and then copy
|
|
// it. NOTE that I can use sizeof here since the buffer is
|
|
// in characters which are 1 byte.
|
|
//
|
|
|
|
if (cFile < sizeof(_pszBitmapFile))
|
|
{
|
|
strcpy(_pszBitmapFile, pszFile);
|
|
_cBitmapFile = cFile;
|
|
}
|
|
else
|
|
{
|
|
hr = ResultFromScode(E_FAIL);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Cleanup
|
|
//
|
|
|
|
if (hMap != INVALID_HANDLE_VALUE)
|
|
{
|
|
CloseHandle(hMap);
|
|
}
|
|
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
|
{
|
|
CloseHandle(hFile);
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CBitmapFile::GetBitmapFileName
|
|
//
|
|
// Synopsis: gets the file name used to set the bitmap
|
|
//
|
|
// Arguments: [pszFile] -- the file
|
|
// [cChar] -- the length of the buffer in characters
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
// History: 4-23-94 KirtD Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
CBitmapFile::GetBitmapFileName (LPSTR pszFile, ULONG cChar) const
|
|
{
|
|
//
|
|
// Check the length of the receiving buffer, making sure the buffer size
|
|
// includes the null terminator
|
|
//
|
|
|
|
if (cChar <= _cBitmapFile)
|
|
{
|
|
return(ResultFromScode(E_INVALIDARG));
|
|
}
|
|
|
|
//
|
|
// Copy the string
|
|
//
|
|
|
|
strcpy(pszFile, _pszBitmapFile);
|
|
|
|
return(ResultFromScode(S_OK));
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CBitmapFile::GetBitmapFileNameLength
|
|
//
|
|
// Synopsis: returns _cBitmapFile
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns: ULONG
|
|
//
|
|
// History: 4-23-94 KirtD Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
ULONG
|
|
CBitmapFile::GetBitmapFileNameLength () const
|
|
{
|
|
return(_cBitmapFile);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CBitmapFile::GetDIBHeight
|
|
//
|
|
// Synopsis: gets the height in pixels of the DIB
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns: LONG
|
|
//
|
|
// History: 4-23-94 KirtD Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
LONG
|
|
CBitmapFile::GetDIBHeight () const
|
|
{
|
|
if (_pbi)
|
|
{
|
|
return(_pbi->bmiHeader.biHeight);
|
|
}
|
|
else
|
|
{
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CBitmapFile::GetDIBWidth
|
|
//
|
|
// Synopsis: gets the width in pixels of the DIB
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns: LONG
|
|
//
|
|
// History: 4-23-94 KirtD Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
LONG
|
|
CBitmapFile::GetDIBWidth () const
|
|
{
|
|
if (_pbi)
|
|
{
|
|
return(_pbi->bmiHeader.biWidth);
|
|
}
|
|
else
|
|
{
|
|
return(0);
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CBitmapFile::GetLogicalPalette
|
|
//
|
|
// Synopsis: gets the logical palette from the DIB
|
|
//
|
|
// Arguments: [pplogpal] -- logical palette goes here
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
// History: 4-23-94 KirtD Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
CBitmapFile::GetLogicalPalette (LPLOGPALETTE *pplogpal) const
|
|
{
|
|
HRESULT hr = ResultFromScode(S_OK);
|
|
LOGPALETTE *plogpal = NULL;
|
|
WORD cPalEntry;
|
|
LPMALLOC pMalloc = NULL;
|
|
|
|
//
|
|
// First check to see if we have been initialized with a bitmap
|
|
//
|
|
|
|
if (_pbi == NULL)
|
|
{
|
|
return(ResultFromScode(E_FAIL));
|
|
}
|
|
|
|
//
|
|
// Check to see if this bit count allows a palette
|
|
//
|
|
|
|
if (HasPaletteData() == FALSE)
|
|
{
|
|
return(ResultFromScode(E_FAIL));
|
|
}
|
|
|
|
//
|
|
// NOTE: We are about to get the number of palette entries we
|
|
// need to allocate, we do NOT use biClrUsed since we
|
|
// know that if this field was set the bitmap would
|
|
// not have been loaded, see BUGBUG in
|
|
// _GetBitmapDataFromBuffer notes section. This is
|
|
// probably a good candidate for an assert.
|
|
//
|
|
|
|
//
|
|
// Get the palette entries
|
|
//
|
|
|
|
cPalEntry = (WORD) (1 << _pbi->bmiHeader.biBitCount);
|
|
|
|
//
|
|
// Allocate a LOGPALETTE
|
|
//
|
|
|
|
hr = CoGetMalloc(MEMCTX_TASK, &pMalloc);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
plogpal = (LOGPALETTE *)pMalloc->Alloc(sizeof(LOGPALETTE)+
|
|
((cPalEntry-1)*
|
|
sizeof(PALETTEENTRY)));
|
|
|
|
if (plogpal == NULL)
|
|
{
|
|
hr = ResultFromScode(E_OUTOFMEMORY);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Copy the palette information
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ULONG cCount;
|
|
|
|
plogpal->palVersion = 0x300;
|
|
plogpal->palNumEntries = cPalEntry;
|
|
|
|
for (cCount = 0; cCount < cPalEntry; cCount++)
|
|
{
|
|
plogpal->palPalEntry[cCount].peRed = _pbi->bmiColors[cCount].rgbRed;
|
|
plogpal->palPalEntry[cCount].peGreen = _pbi->bmiColors[cCount].rgbGreen;
|
|
plogpal->palPalEntry[cCount].peBlue = _pbi->bmiColors[cCount].rgbBlue;
|
|
plogpal->palPalEntry[cCount].peFlags = PC_NOCOLLAPSE;
|
|
}
|
|
|
|
*pplogpal = plogpal;
|
|
}
|
|
|
|
//
|
|
// Cleanup
|
|
//
|
|
|
|
if (pMalloc)
|
|
{
|
|
pMalloc->Release();
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CBitmapFile::CreateDIBInHGlobal
|
|
//
|
|
// Synopsis: creates a DIB i.e. info and data in a GlobalAlloc'd buffer
|
|
//
|
|
// Arguments: [phGlobal] -- handle goes here
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
// History: 5-06-94 KirtD Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
CBitmapFile::CreateDIBInHGlobal (HGLOBAL *phGlobal) const
|
|
{
|
|
HRESULT hr = ResultFromScode(S_OK);
|
|
ULONG cb = 0;
|
|
LPBYTE pb = NULL;
|
|
HGLOBAL hGlobal = NULL;
|
|
ULONG cbPalEntry = 0;
|
|
|
|
//
|
|
// Check to see if we are initialized
|
|
//
|
|
|
|
if (_pbi == NULL)
|
|
{
|
|
return(ResultFromScode(E_FAIL));
|
|
}
|
|
|
|
//
|
|
// The size to allocate for the data must be calculated
|
|
// from the following ...
|
|
//
|
|
|
|
//
|
|
// The size of the bitmap info plus the size of the data
|
|
//
|
|
|
|
cb = _cbi + _cbData;
|
|
|
|
//
|
|
// Allocate
|
|
//
|
|
|
|
hGlobal = GlobalAlloc(GHND, cb);
|
|
if (hGlobal == NULL)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
|
|
//
|
|
// Lock the handle
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pb = (LPBYTE)GlobalLock(hGlobal);
|
|
if (pb == NULL)
|
|
{
|
|
hr = HRESULT_FROM_WIN32(GetLastError());
|
|
}
|
|
}
|
|
|
|
//
|
|
// Copy the information
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// First the bitmap info
|
|
//
|
|
|
|
memcpy(pb, _pbi, _cbi);
|
|
|
|
//
|
|
// Move pointer but if there is no palette compensate
|
|
// for the extra RGBQUAD
|
|
//
|
|
|
|
if (_pbi->bmiHeader.biBitCount == BMP_24_BITSPERPIXEL)
|
|
{
|
|
pb += (_cbi - sizeof(RGBQUAD));
|
|
}
|
|
else
|
|
{
|
|
pb += _cbi;
|
|
}
|
|
|
|
//
|
|
// Now the bits
|
|
//
|
|
|
|
memcpy(pb, _pbData, _cbData);
|
|
}
|
|
|
|
//
|
|
// Cleanup
|
|
//
|
|
|
|
//
|
|
// If we locked the handle, unlock it
|
|
//
|
|
|
|
if (pb)
|
|
{
|
|
GlobalUnlock(hGlobal);
|
|
}
|
|
|
|
//
|
|
// If we succeeded, set the out parameter, if we failed and
|
|
// we had allocated the hGlobal, free it
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
*phGlobal = hGlobal;
|
|
}
|
|
else if (hGlobal)
|
|
{
|
|
GlobalFree(hGlobal);
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CBitmapFile::HasPaletteData
|
|
//
|
|
// Synopsis: returns whether or not the dib has palette data
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns: BOOL
|
|
//
|
|
// History: 5-16-94 kirtd Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
CBitmapFile::HasPaletteData () const
|
|
{
|
|
//
|
|
// If we are not initialized return FALSE
|
|
//
|
|
|
|
if (_pbi == NULL)
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
//
|
|
// If we are a 24, 16 or 32 bpp DIB then we do not have
|
|
// palette data
|
|
//
|
|
// BUGBUG: The case where biClrUsed is set is not dealt
|
|
// with
|
|
//
|
|
|
|
if ((_pbi->bmiHeader.biBitCount == BMP_24_BITSPERPIXEL) ||
|
|
(_pbi->bmiHeader.biBitCount == BMP_16_BITSPERPIXEL) ||
|
|
(_pbi->bmiHeader.biBitCount == BMP_32_BITSPERPIXEL))
|
|
{
|
|
return(FALSE);
|
|
}
|
|
|
|
//
|
|
// Otherwise we do have palette data
|
|
//
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CBitmapFile::GetDIBBits
|
|
//
|
|
// Synopsis: gets the bits
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns: LPBYTE
|
|
//
|
|
// History: 5-02-94 KirtD Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
LPBYTE
|
|
CBitmapFile::GetDIBBits ()
|
|
{
|
|
return(_pbData);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CBitmapFile::GetBitmapInfo
|
|
//
|
|
// Synopsis: gets the bitmap info pointer
|
|
//
|
|
// Arguments: (none)
|
|
//
|
|
// Returns: LPBITMAPINFO
|
|
//
|
|
// History: 5-14-94 kirtd Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
LPBITMAPINFO
|
|
CBitmapFile::GetBitmapInfo ()
|
|
{
|
|
return(_pbi);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CBitmapFile::_GetBitmapDataFromBuffer
|
|
//
|
|
// Synopsis: gets the bitmap data from the given buffer
|
|
//
|
|
// Arguments: [pbuffer] -- the buffer
|
|
// [cb] -- the buffer size
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
// History: 4-23-94 KirtD Created
|
|
//
|
|
// Notes: BUGBUG: If biClrUsed is set the bitmap is not loaded
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
CBitmapFile::_GetBitmapDataFromBuffer (LPBYTE pbuffer, ULONG cb)
|
|
{
|
|
HRESULT hr = ResultFromScode(S_OK);
|
|
BITMAPFILEHEADER bmfh;
|
|
BITMAPCOREHEADER *pbch;
|
|
BITMAPINFOHEADER bih;
|
|
LPBYTE pbStart;
|
|
ULONG cbi = 0;
|
|
ULONG cbData;
|
|
LPBITMAPINFO pbi = NULL;
|
|
LPBYTE pbData = NULL;
|
|
DWORD dwSizeOfHeader;
|
|
|
|
//
|
|
// Record the starting position
|
|
//
|
|
|
|
pbStart = pbuffer;
|
|
|
|
//
|
|
// First validate the buffer for size
|
|
//
|
|
|
|
if (cb < sizeof(BITMAPFILEHEADER))
|
|
{
|
|
return(ResultFromScode(E_FAIL));
|
|
}
|
|
|
|
//
|
|
// Now get the bitmap file header
|
|
//
|
|
|
|
memcpy(&bmfh, pbuffer, sizeof(BITMAPFILEHEADER));
|
|
|
|
//
|
|
// Validate the information
|
|
//
|
|
|
|
hr = _ValidateBitmapFileHeader (&bmfh, cb);
|
|
|
|
//
|
|
// Get the next 4 bytes which will represent the size of the
|
|
// next structure and allow us to determine the type
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
pbuffer += sizeof(BITMAPFILEHEADER);
|
|
memcpy(&dwSizeOfHeader, pbuffer, sizeof(DWORD));
|
|
|
|
if (dwSizeOfHeader == sizeof(BITMAPCOREHEADER))
|
|
{
|
|
pbch = (BITMAPCOREHEADER *)pbuffer;
|
|
memset(&bih, 0, sizeof(BITMAPINFOHEADER));
|
|
|
|
bih.biSize = sizeof(BITMAPINFOHEADER);
|
|
bih.biWidth = pbch->bcWidth;
|
|
bih.biHeight = pbch->bcHeight;
|
|
bih.biPlanes = pbch->bcPlanes;
|
|
bih.biBitCount = pbch->bcBitCount;
|
|
|
|
pbuffer += sizeof(BITMAPCOREHEADER);
|
|
}
|
|
else if (dwSizeOfHeader == sizeof(BITMAPINFOHEADER))
|
|
{
|
|
memcpy(&bih, pbuffer, sizeof(BITMAPINFOHEADER));
|
|
|
|
pbuffer += sizeof(BITMAPINFOHEADER);
|
|
}
|
|
else
|
|
{
|
|
hr = ResultFromScode(E_FAIL);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Check if biClrUsed is set since we do not handle that
|
|
// case at this time
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (bih.biClrUsed != 0)
|
|
{
|
|
hr = ResultFromScode(E_FAIL);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now we need to calculate the size of the BITMAPINFO we need
|
|
// to allocate including any palette information
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// First the size of the header
|
|
//
|
|
|
|
cbi = sizeof(BITMAPINFOHEADER);
|
|
|
|
//
|
|
// Now the palette
|
|
//
|
|
|
|
if (bih.biBitCount == BMP_24_BITSPERPIXEL)
|
|
{
|
|
//
|
|
// Just add on the 1 RGBQUAD for the structure but
|
|
// there is no palette
|
|
//
|
|
|
|
cbi += sizeof(RGBQUAD);
|
|
}
|
|
else if ((bih.biBitCount == BMP_16_BITSPERPIXEL) ||
|
|
(bih.biBitCount == BMP_32_BITSPERPIXEL))
|
|
{
|
|
//
|
|
// Add on the 3 DWORD masks which are used to
|
|
// get the colors out of the data
|
|
//
|
|
|
|
cbi += (3 * sizeof(DWORD));
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Anything else we just use the bit count to calculate
|
|
// the number of entries
|
|
//
|
|
|
|
cbi += ((1 << bih.biBitCount) * sizeof(RGBQUAD));
|
|
}
|
|
|
|
//
|
|
// Now allocate the BITMAPINFO
|
|
//
|
|
|
|
pbi = (LPBITMAPINFO) new BYTE [cbi];
|
|
if (pbi == NULL)
|
|
{
|
|
hr = ResultFromScode(E_OUTOFMEMORY);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Fill in the BITMAPINFO data structure and get the bits
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// First copy the header data
|
|
//
|
|
|
|
memcpy(&(pbi->bmiHeader), &bih, sizeof(BITMAPINFOHEADER));
|
|
|
|
//
|
|
// Now the palette data
|
|
//
|
|
|
|
if (bih.biBitCount == BMP_24_BITSPERPIXEL)
|
|
{
|
|
//
|
|
// No palette data to copy
|
|
//
|
|
}
|
|
else if ((bih.biBitCount == BMP_16_BITSPERPIXEL) ||
|
|
(bih.biBitCount == BMP_32_BITSPERPIXEL))
|
|
{
|
|
//
|
|
// Copy the 3 DWORD masks
|
|
//
|
|
|
|
memcpy(&(pbi->bmiColors), pbuffer, 3*sizeof(DWORD));
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// If we were a BITMAPCOREHEADER type then we have our
|
|
// palette data in the form of RGBTRIPLEs so we must
|
|
// explicitly copy each. Otherwise we can just memcpy
|
|
// the RGBQUADs
|
|
//
|
|
|
|
if (dwSizeOfHeader == sizeof(BITMAPCOREHEADER))
|
|
{
|
|
ULONG cPalEntry = (1 << bih.biBitCount);
|
|
ULONG cCount;
|
|
RGBTRIPLE *argbt = (RGBTRIPLE *)pbuffer;
|
|
|
|
for (cCount = 0; cCount < cPalEntry; cCount++)
|
|
{
|
|
pbi->bmiColors[cCount].rgbRed =
|
|
argbt[cCount].rgbtRed;
|
|
pbi->bmiColors[cCount].rgbGreen =
|
|
argbt[cCount].rgbtGreen;
|
|
pbi->bmiColors[cCount].rgbBlue =
|
|
argbt[cCount].rgbtBlue;
|
|
|
|
pbi->bmiColors[cCount].rgbReserved = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ULONG cbPalette = (1 << bih.biBitCount) * sizeof(RGBQUAD);
|
|
|
|
memcpy(&(pbi->bmiColors), pbuffer, cbPalette);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now find out where the bits are
|
|
//
|
|
|
|
pbuffer = pbStart + bmfh.bfOffBits;
|
|
|
|
//
|
|
// Get the size to copy
|
|
//
|
|
|
|
cbData = cb - bmfh.bfOffBits;
|
|
|
|
//
|
|
// Allocate the buffer to hold the bits
|
|
//
|
|
|
|
pbData = new BYTE [cbData];
|
|
if (pbData == NULL)
|
|
{
|
|
hr = ResultFromScode(E_OUTOFMEMORY);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
memcpy(pbData, pbuffer, cbData);
|
|
}
|
|
}
|
|
|
|
//
|
|
// If everything succeeded record the data
|
|
//
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//
|
|
// Record the info
|
|
//
|
|
|
|
delete _pbi;
|
|
_cbi = cbi;
|
|
_pbi = pbi;
|
|
|
|
//
|
|
// Record the data
|
|
//
|
|
|
|
delete _pbData;
|
|
_cbData = cbData;
|
|
_pbData = pbData;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Cleanup
|
|
//
|
|
|
|
delete pbi;
|
|
delete pbData;
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CBitmapFile::_ValidateBitmapFileHeader
|
|
//
|
|
// Synopsis: validates a bitmap file header
|
|
//
|
|
// Arguments: [pbmfh] -- bitmap file header
|
|
// [cbFile] -- bitmap file size
|
|
//
|
|
// Returns: HRESULT
|
|
//
|
|
// History: 4-23-94 KirtD Created
|
|
//
|
|
// Notes:
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
HRESULT
|
|
CBitmapFile::_ValidateBitmapFileHeader (BITMAPFILEHEADER *pbmfh, ULONG cbFile)
|
|
{
|
|
//
|
|
// Check for the following,
|
|
//
|
|
// 1. The bfType member contains 'BM'
|
|
// 2. The bfOffset member is NOT greater than the size of the file
|
|
//
|
|
|
|
if ((pbmfh->bfType == 0x4d42) && (pbmfh->bfOffBits <= cbFile))
|
|
{
|
|
return(ResultFromScode(S_OK));
|
|
}
|
|
|
|
return(ResultFromScode(E_FAIL));
|
|
}
|