windows-xp/Source/XPSP1/NT/com/oleutest/cachetst/bmpfile.cxx

//+---------------------------------------------------------------------------
//
//  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));
}