#include #include "bmplib.h" /* * This came from: \\index1\src\nt\private\samples\wincap32\dibutil.c */ #define IS_WIN30_DIB(lpbi) ((*(LPDWORD)(lpbi)) == sizeof(BITMAPINFOHEADER)) #define WIDTHBYTES(bits) (((bits) + 31) / 32 * 4) #define DIB_HEADER_MARKER ((WORD) ('M' << 8) | 'B') WORD DIBNumColors(LPSTR lpDIB) { WORD wBitCount; // DIB bit count // If this is a Windows-style DIB, the number of colors in the // color table can be less than the number of bits per pixel // allows for (i.e. lpbi->biClrUsed can be set to some value). // If this is the case, return the appropriate value. if (IS_WIN30_DIB(lpDIB)) { DWORD dwClrUsed; dwClrUsed = ((LPBITMAPINFOHEADER)lpDIB)->biClrUsed; if (dwClrUsed) return (WORD)dwClrUsed; } // Calculate the number of colors in the color table based on // the number of bits per pixel for the DIB. if (IS_WIN30_DIB(lpDIB)) wBitCount = ((LPBITMAPINFOHEADER)lpDIB)->biBitCount; else wBitCount = ((LPBITMAPCOREHEADER)lpDIB)->bcBitCount; // return number of colors based on bits per pixel switch (wBitCount) { case 1: return 2; case 4: return 16; case 8: return 256; default: return 0; } } WORD PaletteSize(LPSTR lpDIB) { // calculate the size required by the palette if (IS_WIN30_DIB (lpDIB)) return (DIBNumColors(lpDIB) * sizeof(RGBQUAD)); else return (DIBNumColors(lpDIB) * sizeof(RGBTRIPLE)); } LPSTR FindDIBBits(LPSTR lpDIB) { return (lpDIB + *(LPDWORD)lpDIB + PaletteSize(lpDIB)); } /************************************************************************* * * DIBToBitmap() * * Parameters: * * HDIB hDIB - specifies the DIB to convert * * HPALETTE hPal - specifies the palette to use with the bitmap * * Return Value: * * HBITMAP - identifies the device-dependent bitmap * * Description: * * This function creates a bitmap from a DIB using the specified palette. * If no palette is specified, default is used. * * NOTE: * * The bitmap returned from this funciton is always a bitmap compatible * with the screen (e.g. same bits/pixel and color planes) rather than * a bitmap with the same attributes as the DIB. This behavior is by * design, and occurs because this function calls CreateDIBitmap to * do its work, and CreateDIBitmap always creates a bitmap compatible * with the hDC parameter passed in (because it in turn calls * CreateCompatibleBitmap). * * So for instance, if your DIB is a monochrome DIB and you call this * function, you will not get back a monochrome HBITMAP -- you will * get an HBITMAP compatible with the screen DC, but with only 2 * colors used in the bitmap. * * If your application requires a monochrome HBITMAP returned for a * monochrome DIB, use the function SetDIBits(). * * Also, the DIBpassed in to the function is not destroyed on exit. This * must be done later, once it is no longer needed. * ************************************************************************/ HBITMAP BMPAPI DIBToBitmap( LPVOID pDIB, HPALETTE hPal ) { LPSTR lpDIBHdr, lpDIBBits; // pointer to DIB header, pointer to DIB bits HBITMAP hBitmap; // handle to device-dependent bitmap HDC hDC; // handle to DC HPALETTE hOldPal = NULL; // handle to a palette // if invalid handle, return NULL if (!pDIB) return NULL; // lock memory block and get a pointer to it lpDIBHdr = pDIB; // get a pointer to the DIB bits lpDIBBits = FindDIBBits(lpDIBHdr); // get a DC hDC = GetDC(NULL); if (!hDC) { return NULL; } // select and realize palette if (hPal) hOldPal = SelectPalette(hDC, hPal, FALSE); RealizePalette(hDC); // create bitmap from DIB info. and bits hBitmap = CreateDIBitmap(hDC, (LPBITMAPINFOHEADER)lpDIBHdr, CBM_INIT, lpDIBBits, (LPBITMAPINFO)lpDIBHdr, DIB_RGB_COLORS); // restore previous palette if (hOldPal) SelectPalette(hDC, hOldPal, FALSE); // clean up ReleaseDC(NULL, hDC); // return handle to the bitmap return hBitmap; } /************************************************************************* * * BitmapToDIB() * * Parameters: * * HBITMAP hBitmap - specifies the bitmap to convert * * HPALETTE hPal - specifies the palette to use with the bitmap * * Return Value: * * HANDLE - identifies the device-dependent bitmap * * Description: * * This function creates a DIB from a bitmap using the specified palette. * ************************************************************************/ HANDLE BMPAPI BitmapToDIB( HBITMAP hBitmap, HPALETTE hPal ) { BITMAP bm; // bitmap structure BITMAPINFOHEADER bi; // bitmap header LPBITMAPINFOHEADER lpbi; // pointer to BITMAPINFOHEADER DWORD dwLen; // size of memory block HANDLE hDIB, h; // handle to DIB, temp handle HDC hDC; // handle to DC WORD biBits; // bits per pixel // check if bitmap handle is valid if (!hBitmap) return NULL; // fill in BITMAP structure, return NULL if it didn't work if (!GetObject(hBitmap, sizeof(bm), (LPSTR)&bm)) return NULL; // if no palette is specified, use default palette if (hPal == NULL) hPal = GetStockObject(DEFAULT_PALETTE); // calculate bits per pixel biBits = bm.bmPlanes * bm.bmBitsPixel; // make sure bits per pixel is valid if (biBits <= 1) biBits = 1; else if (biBits <= 4) biBits = 4; else if (biBits <= 8) biBits = 8; else // if greater than 8-bit, force to 24-bit biBits = 24; // initialize BITMAPINFOHEADER bi.biSize = sizeof(BITMAPINFOHEADER); bi.biWidth = bm.bmWidth; bi.biHeight = bm.bmHeight; bi.biPlanes = 1; bi.biBitCount = biBits; bi.biCompression = BI_RGB; bi.biSizeImage = 0; bi.biXPelsPerMeter = 0; bi.biYPelsPerMeter = 0; bi.biClrUsed = 0; bi.biClrImportant = 0; // calculate size of memory block required to store BITMAPINFO dwLen = bi.biSize + PaletteSize((LPSTR)&bi); // get a DC hDC = GetDC(NULL); if (!hDC) { return NULL; } // select and realize our palette hPal = SelectPalette(hDC, hPal, FALSE); RealizePalette(hDC); // alloc memory block to store our bitmap hDIB = GlobalAlloc(GHND, dwLen); // if we couldn't get memory block if (!hDIB) { // clean up and return NULL SelectPalette(hDC, hPal, TRUE); RealizePalette(hDC); ReleaseDC(NULL, hDC); return NULL; } // lock memory and get pointer to it lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB); /// use our bitmap info. to fill BITMAPINFOHEADER *lpbi = bi; // call GetDIBits with a NULL lpBits param, so it will calculate the // biSizeImage field for us GetDIBits(hDC, hBitmap, 0, (UINT)bi.biHeight, NULL, (LPBITMAPINFO)lpbi, DIB_RGB_COLORS); // get the info. returned by GetDIBits and unlock memory block bi = *lpbi; GlobalUnlock(hDIB); // if the driver did not fill in the biSizeImage field, make one up if (bi.biSizeImage == 0) bi.biSizeImage = WIDTHBYTES((DWORD)bm.bmWidth * biBits) * bm.bmHeight; // realloc the buffer big enough to hold all the bits dwLen = bi.biSize + PaletteSize((LPSTR)&bi) + bi.biSizeImage; if (h = GlobalReAlloc(hDIB, dwLen, 0)) hDIB = h; else { // clean up and return NULL GlobalFree(hDIB); hDIB = NULL; SelectPalette(hDC, hPal, TRUE); RealizePalette(hDC); ReleaseDC(NULL, hDC); return NULL; } // lock memory block and get pointer to it */ lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB); // call GetDIBits with a NON-NULL lpBits param, and actualy get the // bits this time if (GetDIBits(hDC, hBitmap, 0, (UINT)bi.biHeight, (LPSTR)lpbi + (WORD)lpbi->biSize + PaletteSize((LPSTR)lpbi), (LPBITMAPINFO)lpbi, DIB_RGB_COLORS) == 0) { // clean up and return NULL GlobalUnlock(hDIB); hDIB = NULL; SelectPalette(hDC, hPal, TRUE); RealizePalette(hDC); ReleaseDC(NULL, hDC); return NULL; } bi = *lpbi; // clean up GlobalUnlock(hDIB); SelectPalette(hDC, hPal, TRUE); RealizePalette(hDC); ReleaseDC(NULL, hDC); // return handle to the DIB return hDIB; } /************************************************************************* * * SaveDIB() * * Saves the specified DIB into the specified file name on disk. No * error checking is done, so if the file already exists, it will be * written over. * * Parameters: * * HDIB hDib - Handle to the dib to save * * LPSTR lpFileName - pointer to full pathname to save DIB under * * Return value: 0 if successful, or one of: * ERR_INVALIDHANDLE * ERR_OPEN * ERR_LOCK * *************************************************************************/ BOOL BMPAPI SaveDIB( LPVOID pDib, LPCSTR lpFileName ) { BITMAPFILEHEADER bmfHdr; // Header for Bitmap file LPBITMAPINFOHEADER lpBI; // Pointer to DIB info structure HANDLE fh; // file handle for opened file DWORD dwDIBSize; DWORD dwWritten; if (!pDib) return FALSE; fh = CreateFile(lpFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL); if (fh == INVALID_HANDLE_VALUE) return FALSE; // Get a pointer to the DIB memory, the first of which contains // a BITMAPINFO structure lpBI = (LPBITMAPINFOHEADER)pDib; if (!lpBI) { CloseHandle(fh); return FALSE; } // Check to see if we're dealing with an OS/2 DIB. If so, don't // save it because our functions aren't written to deal with these // DIBs. if (lpBI->biSize != sizeof(BITMAPINFOHEADER)) { CloseHandle(fh); return FALSE; } // Fill in the fields of the file header // Fill in file type (first 2 bytes must be "BM" for a bitmap) bmfHdr.bfType = DIB_HEADER_MARKER; // "BM" // Calculating the size of the DIB is a bit tricky (if we want to // do it right). The easiest way to do this is to call GlobalSize() // on our global handle, but since the size of our global memory may have // been padded a few bytes, we may end up writing out a few too // many bytes to the file (which may cause problems with some apps, // like HC 3.0). // // So, instead let's calculate the size manually. // // To do this, find size of header plus size of color table. Since the // first DWORD in both BITMAPINFOHEADER and BITMAPCOREHEADER conains // the size of the structure, let's use this. // Partial Calculation dwDIBSize = *(LPDWORD)lpBI + PaletteSize((LPSTR)lpBI); // Now calculate the size of the image // It's an RLE bitmap, we can't calculate size, so trust the biSizeImage // field if ((lpBI->biCompression == BI_RLE8) || (lpBI->biCompression == BI_RLE4)) dwDIBSize += lpBI->biSizeImage; else { DWORD dwBmBitsSize; // Size of Bitmap Bits only // It's not RLE, so size is Width (DWORD aligned) * Height dwBmBitsSize = WIDTHBYTES((lpBI->biWidth)*((DWORD)lpBI->biBitCount)) * lpBI->biHeight; dwDIBSize += dwBmBitsSize; // Now, since we have calculated the correct size, why don't we // fill in the biSizeImage field (this will fix any .BMP files which // have this field incorrect). lpBI->biSizeImage = dwBmBitsSize; } // Calculate the file size by adding the DIB size to sizeof(BITMAPFILEHEADER) bmfHdr.bfSize = dwDIBSize + sizeof(BITMAPFILEHEADER); bmfHdr.bfReserved1 = 0; bmfHdr.bfReserved2 = 0; // Now, calculate the offset the actual bitmap bits will be in // the file -- It's the Bitmap file header plus the DIB header, // plus the size of the color table. bmfHdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + lpBI->biSize + PaletteSize((LPSTR)lpBI); // Write the file header WriteFile(fh, (LPSTR)&bmfHdr, sizeof(BITMAPFILEHEADER), &dwWritten, NULL); // Write the DIB header and the bits -- use local version of // MyWrite, so we can write more than 32767 bytes of data WriteFile(fh, (LPSTR)lpBI, dwDIBSize, &dwWritten, NULL); CloseHandle(fh); if (dwWritten == 0) return FALSE; // oops, something happened in the write else return TRUE; // Success code } /************************************************************************* * * Function: ReadDIBFile (int) * * Purpose: Reads in the specified DIB file into a global chunk of * memory. * * Returns: A handle to a dib (hDIB) if successful. * NULL if an error occurs. * * Comments: BITMAPFILEHEADER is stripped off of the DIB. Everything * from the end of the BITMAPFILEHEADER structure on is * returned in the global memory handle. * * * NOTE: The DIB API were not written to handle OS/2 DIBs, so this * function will reject any file that is not a Windows DIB. * *************************************************************************/ HANDLE BMPAPI ReadDIBFile( HANDLE hFile ) { BITMAPFILEHEADER bmfHeader; DWORD dwBitsSize; UINT nNumColors; // Number of colors in table HANDLE hDIB; HANDLE hDIBtmp; // Used for GlobalRealloc() //MPB LPBITMAPINFOHEADER lpbi; DWORD offBits; DWORD dwRead; // get length of DIB in bytes for use when reading dwBitsSize = GetFileSize(hFile, NULL); // Allocate memory for header & color table. We'll enlarge this // memory as needed. hDIB = GlobalAlloc(GMEM_MOVEABLE, (DWORD)(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD))); if (!hDIB) return NULL; lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB); if (!lpbi) { GlobalFree(hDIB); return NULL; } // read the BITMAPFILEHEADER from our file if (!ReadFile(hFile, (LPSTR)&bmfHeader, sizeof (BITMAPFILEHEADER), &dwRead, NULL)) goto ErrExit; if (sizeof (BITMAPFILEHEADER) != dwRead) goto ErrExit; if (bmfHeader.bfType != 0x4d42) // 'BM' goto ErrExit; // read the BITMAPINFOHEADER if (!ReadFile(hFile, (LPSTR)lpbi, sizeof(BITMAPINFOHEADER), &dwRead, NULL)) goto ErrExit; if (sizeof(BITMAPINFOHEADER) != dwRead) goto ErrExit; // Check to see that it's a Windows DIB -- an OS/2 DIB would cause // strange problems with the rest of the DIB API since the fields // in the header are different and the color table entries are // smaller. // // If it's not a Windows DIB (e.g. if biSize is wrong), return NULL. if (lpbi->biSize == sizeof(BITMAPCOREHEADER)) goto ErrExit; // Now determine the size of the color table and read it. Since the // bitmap bits are offset in the file by bfOffBits, we need to do some // special processing here to make sure the bits directly follow // the color table (because that's the format we are susposed to pass // back) if (!(nNumColors = (UINT)lpbi->biClrUsed)) { // no color table for 24-bit, default size otherwise if (lpbi->biBitCount != 24) nNumColors = 1 << lpbi->biBitCount; // standard size table } // fill in some default values if they are zero if (lpbi->biClrUsed == 0) lpbi->biClrUsed = nNumColors; if (lpbi->biSizeImage == 0) { lpbi->biSizeImage = ((((lpbi->biWidth * (DWORD)lpbi->biBitCount) + 31) & ~31) >> 3) * lpbi->biHeight; } // get a proper-sized buffer for header, color table and bits GlobalUnlock(hDIB); hDIBtmp = GlobalReAlloc(hDIB, lpbi->biSize + nNumColors * sizeof(RGBQUAD) + lpbi->biSizeImage, 0); if (!hDIBtmp) // can't resize buffer for loading goto ErrExitNoUnlock; //MPB else hDIB = hDIBtmp; lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDIB); // read the color table ReadFile (hFile, (LPSTR)(lpbi) + lpbi->biSize, nNumColors * sizeof(RGBQUAD), &dwRead, NULL); // offset to the bits from start of DIB header offBits = lpbi->biSize + nNumColors * sizeof(RGBQUAD); // If the bfOffBits field is non-zero, then the bits might *not* be // directly following the color table in the file. Use the value in // bfOffBits to seek the bits. if (bmfHeader.bfOffBits != 0L) SetFilePointer(hFile, bmfHeader.bfOffBits, NULL, FILE_BEGIN); if (ReadFile(hFile, (LPSTR)lpbi + offBits, lpbi->biSizeImage, &dwRead, NULL)) goto OKExit; ErrExit: GlobalUnlock(hDIB); ErrExitNoUnlock: GlobalFree(hDIB); return NULL; OKExit: GlobalUnlock(hDIB); return hDIB; } //==================================== BOOL BMPAPI SaveBitmapInFile( HBITMAP hBitmap, LPCSTR szFileName ) { BOOL rv = FALSE; HANDLE hDIB = NULL; LPVOID pDIB = NULL; if (!hBitmap) goto exitpt; hDIB = BitmapToDIB(hBitmap, NULL); if (!hDIB) { // TRC(ERR, "Can't get DIB bits\n"); goto exitpt; } pDIB = GlobalLock(hDIB); if (!pDIB) goto exitpt; if (!SaveDIB(pDIB, szFileName)) goto exitpt; rv = TRUE; exitpt: if (pDIB) GlobalUnlock(hDIB); if (hDIB) GlobalFree(hDIB); return rv; } HANDLE ReadDIBFromFile(LPCSTR szFileName) { HANDLE hFile; HANDLE hDIB = NULL; hFile = CreateFile(szFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL); if (hFile != INVALID_HANDLE_VALUE) { hDIB = ReadDIBFile(hFile); CloseHandle(hFile); } return hDIB; } /* * size and color depth are already checked * the number of colors is 16 or 256 */ BOOL _CompareBits16to256( LPBITMAPINFO pbmi1, // 16 color bitmap LPBITMAPINFO pbmi2, // 256 color bitmap HDC hdcOutput ) { BOOL rv = TRUE; INT nX, nY; INT nWidth, nHeight; INT nLineSize1, nLineSize2; RGBQUAD *pColorTable1; RGBQUAD *pColorTable2; LPSTR pBits1, pBits2; HBRUSH hRedBrush = NULL; if (!pbmi1 || !pbmi2) { // TRC(ERR, "NULL pointers passed\n"); rv = FALSE; goto exitpt; } nLineSize1 = WIDTHBYTES(pbmi1->bmiHeader.biWidth*4); nLineSize2 = WIDTHBYTES(pbmi1->bmiHeader.biWidth*8); pColorTable1 = (RGBQUAD *)(((LPSTR)pbmi1) + pbmi1->bmiHeader.biSize); pColorTable2 = (RGBQUAD *)(((LPSTR)pbmi2) + pbmi2->bmiHeader.biSize); pBits1 = FindDIBBits((LPSTR)pbmi1); pBits2 = FindDIBBits((LPSTR)pbmi2); nWidth = pbmi1->bmiHeader.biWidth; nHeight = pbmi1->bmiHeader.biHeight; hRedBrush = CreateHatchBrush(HS_FDIAGONAL, RGB(255, 0, 0)); SetBkMode(hdcOutput, TRANSPARENT); SetBrushOrgEx(hdcOutput, 0, 0, NULL); SetROP2(hdcOutput, R2_COPYPEN); for (nY = 0; nY < pbmi1->bmiHeader.biHeight; nY++) { for (nX = 0; nX < pbmi1->bmiHeader.biWidth; nX += 2) { PBYTE pPix1 = pBits1 + nLineSize1 * nY + nX / 2; PBYTE pPix2 = pBits2 + nLineSize2 * nY + nX; BYTE Pix1 = (*pPix1) >> 4; BYTE Pix2 = (*pPix2); RGBQUAD *pQuad1 = pColorTable1 + (Pix1); RGBQUAD *pQuad2 = pColorTable2 + (Pix2); BOOL cmp = pQuad1->rgbBlue == pQuad2->rgbBlue && pQuad1->rgbGreen == pQuad2->rgbGreen && pQuad1->rgbRed == pQuad2->rgbRed; if (cmp) { Pix1 = (*pPix1) & 0xf; Pix2 = (*(pPix2 + 1)); pQuad1 = pColorTable1 + (Pix1); pQuad2 = pColorTable2 + (Pix2); cmp = pQuad1->rgbBlue == pQuad2->rgbBlue && pQuad1->rgbGreen == pQuad2->rgbGreen && pQuad1->rgbRed == pQuad2->rgbRed; } if (!cmp) { HRGN hrgn; hrgn = CreateRectRgn(nX - 3, nHeight - nY - 3, nX + 4, nHeight - nY + 4); if ( NULL != hrgn ) { FillRgn(hdcOutput, hrgn, hRedBrush); DeleteObject(hrgn); } } rv = rv && cmp; } } exitpt: if (hRedBrush) DeleteObject(hRedBrush); return rv; } BOOL _CompareBits16( LPBITMAPINFO pbmi1, LPBITMAPINFO pbmi2, HDC hdcOutput ) { BOOL rv = TRUE; INT nX, nY; INT nWidth, nHeight; INT nLineSize; RGBQUAD *pColorTable1; RGBQUAD *pColorTable2; LPSTR pBits1, pBits2; HBRUSH hRedBrush = NULL; if (!pbmi1 || !pbmi2) { // TRC(ERR, "NULL pointers passed\n"); rv = FALSE; goto exitpt; } nLineSize = WIDTHBYTES(pbmi1->bmiHeader.biWidth*4); pColorTable1 = (RGBQUAD *)(((LPSTR)pbmi1) + pbmi1->bmiHeader.biSize); pColorTable2 = (RGBQUAD *)(((LPSTR)pbmi2) + pbmi2->bmiHeader.biSize); pBits1 = FindDIBBits((LPSTR)pbmi1); pBits2 = FindDIBBits((LPSTR)pbmi2); nWidth = pbmi1->bmiHeader.biWidth; nHeight = pbmi1->bmiHeader.biHeight; hRedBrush = CreateHatchBrush(HS_FDIAGONAL, RGB(255, 0, 0)); SetBkMode(hdcOutput, TRANSPARENT); SetBrushOrgEx(hdcOutput, 0, 0, NULL); SetROP2(hdcOutput, R2_COPYPEN); for (nY = 0; nY < pbmi1->bmiHeader.biHeight; nY++) { for (nX = 0; nX < pbmi1->bmiHeader.biWidth; nX += 2) { PBYTE pPix1 = pBits1 + nLineSize * nY + nX / 2; PBYTE pPix2 = pBits2 + nLineSize * nY + nX / 2; BYTE Pix1 = (*pPix1) & 0xf; BYTE Pix2 = (*pPix2) & 0xf; RGBQUAD *pQuad1 = pColorTable1 + (Pix1); RGBQUAD *pQuad2 = pColorTable2 + (Pix2); BOOL cmp = pQuad1->rgbBlue == pQuad2->rgbBlue && pQuad1->rgbGreen == pQuad2->rgbGreen && pQuad1->rgbRed == pQuad2->rgbRed; if (cmp) { Pix1 = (*pPix1) >> 4; Pix2 = (*pPix2) >> 4; pQuad1 = pColorTable1 + (Pix1); pQuad2 = pColorTable2 + (Pix2); cmp = pQuad1->rgbBlue == pQuad2->rgbBlue && pQuad1->rgbGreen == pQuad2->rgbGreen && pQuad1->rgbRed == pQuad2->rgbRed; } if (!cmp) { HRGN hrgn; hrgn = CreateRectRgn(nX - 3, nHeight - nY - 3, nX + 4, nHeight - nY + 4); if ( NULL != hrgn ) { FillRgn(hdcOutput, hrgn, hRedBrush); DeleteObject(hrgn); } } rv = rv && cmp; } } exitpt: if (hRedBrush) DeleteObject(hRedBrush); return rv; } BOOL _CompareBits256( LPBITMAPINFO pbmi1, LPBITMAPINFO pbmi2, HDC hdcOutput ) { BOOL rv = TRUE; INT nX, nY; INT nWidth, nHeight; INT nLineSize; RGBQUAD *pColorTable1; RGBQUAD *pColorTable2; LPSTR pBits1, pBits2; HBRUSH hRedBrush = NULL; if (!pbmi1 || !pbmi2) { // TRC(ERR, "NULL pointers passed\n"); rv = FALSE; goto exitpt; } nLineSize = WIDTHBYTES(pbmi1->bmiHeader.biWidth*8); pColorTable1 = (RGBQUAD *)(((LPSTR)pbmi1) + pbmi1->bmiHeader.biSize); pColorTable2 = (RGBQUAD *)(((LPSTR)pbmi2) + pbmi2->bmiHeader.biSize); pBits1 = FindDIBBits((LPSTR)pbmi1); pBits2 = FindDIBBits((LPSTR)pbmi2); nWidth = pbmi1->bmiHeader.biWidth; nHeight = pbmi1->bmiHeader.biHeight; hRedBrush = CreateHatchBrush(HS_FDIAGONAL, RGB(255, 0, 0)); SetBkMode(hdcOutput, TRANSPARENT); SetBrushOrgEx(hdcOutput, 0, 0, NULL); SetROP2(hdcOutput, R2_COPYPEN); for (nY = 0; nY < pbmi1->bmiHeader.biHeight; nY++) { for (nX = 0; nX < pbmi1->bmiHeader.biWidth; nX++) { PBYTE pPix1 = pBits1 + nLineSize * nY + nX; PBYTE pPix2 = pBits2 + nLineSize * nY + nX; RGBQUAD *pQuad1 = pColorTable1 + (*pPix1); RGBQUAD *pQuad2 = pColorTable2 + (*pPix2); BOOL cmp = pQuad1->rgbBlue == pQuad2->rgbBlue && pQuad1->rgbGreen == pQuad2->rgbGreen && pQuad1->rgbRed == pQuad2->rgbRed; if (!cmp) { HRGN hrgn; hrgn = CreateRectRgn(nX - 3, nHeight - nY - 3, nX + 4, nHeight - nY + 4); if ( NULL != hrgn ) { FillRgn(hdcOutput, hrgn, hRedBrush); DeleteObject(hrgn); } } rv = rv && cmp; } } exitpt: if (hRedBrush) DeleteObject(hRedBrush); return rv; } // // Supports only 4 and 8 color bit DIBs // BOOL BMPAPI CompareTwoDIBs( LPVOID pDIB1, LPVOID pDIB2, HBITMAP *phbmpOutput ) { BOOL rv = FALSE; LPBITMAPINFO pbmi1 = NULL; LPBITMAPINFO pbmi2 = NULL; HBITMAP hbmpOutput = NULL; HDC hdcScreen; HDC hdcMem = NULL; HBITMAP hbmpOld = NULL; if (!phbmpOutput) goto exitpt; // use the second bitmap for the base of the result hbmpOutput = DIBToBitmap(pDIB2, NULL); if (!hbmpOutput) { // TRC(ERR, "Can't create output bitmap\n"); goto exitpt; } pbmi1 = pDIB1; pbmi2 = pDIB2; if (!pbmi1 || !pbmi2) { // TRC(ERR, "Can't lock DIBs\n"); goto exitpt; } hdcScreen = GetDC(NULL); if (hdcScreen) { hdcMem = CreateCompatibleDC(hdcScreen); ReleaseDC(NULL, hdcScreen); } if (!hdcMem) { // TRC(ERR, "Can't get a DC\n"); goto exitpt; } hbmpOld = SelectObject(hdcMem, hbmpOutput); // check the size and color depth of the two bitmaps if (pbmi1->bmiHeader.biWidth != pbmi2->bmiHeader.biWidth || pbmi1->bmiHeader.biHeight != pbmi2->bmiHeader.biHeight) { // TRC(INF, "The two bitmaps have different size\n"); goto exitpt; } // check that we are going to be able to compare the two dibs if ( (pbmi1->bmiHeader.biBitCount != 4 && pbmi1->bmiHeader.biBitCount != 8) || (pbmi2->bmiHeader.biBitCount != 4 && pbmi2->bmiHeader.biBitCount != 8) ) { // TRC(FATAL, "Unsupported format\n"); goto exitpt; } if (pbmi1->bmiHeader.biBitCount == pbmi2->bmiHeader.biBitCount) { // compare the DIB bits if (pbmi1->bmiHeader.biBitCount == 4) rv = _CompareBits16(pbmi1, pbmi2, hdcMem); else rv = _CompareBits256(pbmi1, pbmi2, hdcMem); } else if (pbmi1->bmiHeader.biBitCount != pbmi2->bmiHeader.biBitCount) { if (pbmi1->bmiHeader.biBitCount == 4) rv = _CompareBits16to256(pbmi1, pbmi2, hdcMem); else rv = _CompareBits16to256(pbmi2, pbmi1, hdcMem); } // if different, save the result bitmap if (!rv) { SelectObject(hdcMem, hbmpOld); hbmpOld = NULL; } exitpt: if (hdcMem) { if (hbmpOld) SelectObject(hdcMem, hbmpOld); ReleaseDC(NULL, hdcMem); } if (rv && hbmpOutput) { // bitmaps are equal, delete the resulting bitmap DeleteObject(hbmpOutput); hbmpOutput = NULL; } if (phbmpOutput) *phbmpOutput = hbmpOutput; return rv; } BOOL BMPAPI CompareTwoBitmapFiles( LPCSTR szFile1, LPCSTR szFile2, LPCSTR szResultFileName ) { BOOL rv = FALSE; HANDLE hDIB1 = NULL; HANDLE hDIB2 = NULL; HBITMAP hbmpOutput = NULL; LPVOID pDIB1 = NULL; LPVOID pDIB2 = NULL; hDIB1 = ReadDIBFromFile(szFile1); if (!hDIB1) { // TRC(ERR, "Can't read DIB file %s\n", szFile1); goto exitpt; } hDIB2 = ReadDIBFromFile(szFile2); if (!hDIB2) { // TRC(ERR, "Can't read DIB file %s\n", szFile2); goto exitpt; } pDIB1 = GlobalLock(hDIB1); if (!pDIB1) goto exitpt; pDIB2 = GlobalLock(hDIB2); if (!pDIB2) goto exitpt; rv = CompareTwoDIBs(pDIB1, pDIB2, &hbmpOutput); if (!rv && hbmpOutput) { SaveBitmapInFile(hbmpOutput, szResultFileName); } exitpt: if (hbmpOutput) DeleteObject(hbmpOutput); if (pDIB1) GlobalUnlock(hDIB1); if (pDIB2) GlobalUnlock(hDIB2); if (hDIB1) GlobalFree(hDIB1); if (hDIB2) GlobalFree(hDIB2); return rv; } BOOL GetScreenDIB( INT left, INT top, INT right, INT bottom, HANDLE *phDIB ) { HDC hScreenDC = NULL; HDC hMemDC = NULL; BOOL rv = FALSE; HANDLE hDIB = NULL; HBITMAP hDstBitmap = NULL; HBITMAP hOldDstBmp = NULL; if (!phDIB) goto exitpt; hScreenDC = GetDC(NULL); if (!hScreenDC) goto exitpt; hMemDC = CreateCompatibleDC(hScreenDC); if (!hMemDC) goto exitpt; // Adjust the order of the rectangle if (left > right) { INT c = left; left = right; right = c; } if (top > bottom) { INT c = top; top = bottom; bottom = top; } hDstBitmap = CreateCompatibleBitmap( hScreenDC, right - left, bottom - top); if (!hDstBitmap) goto exitpt; hOldDstBmp = SelectObject(hMemDC, hDstBitmap); if (!BitBlt( hMemDC, 0, 0, // dest x,y right - left, // dest width bottom - top, // dest height hScreenDC, left, top, // source coordinates SRCCOPY)) goto exitpt; hDIB = BitmapToDIB(hDstBitmap, NULL); if (hDIB) rv = TRUE; exitpt: if (hOldDstBmp) SelectObject(hMemDC, hOldDstBmp); if (hDstBitmap) DeleteObject(hDstBitmap); if (hScreenDC) ReleaseDC(NULL, hScreenDC); if (hMemDC) DeleteDC(hMemDC); if (phDIB) (*phDIB) = hDIB; return rv; }