display.cpp

基于块方向的图像无损压缩代码

#include "stdafx.h"
#include "display.h"
extern short int Width,Height;

BOOL WINAPI CreateDIBPalette(HDIB hDIB, CPalette* pPal)
{
	LPLOGPALETTE lpPal;      // pointer to a logical palette
	HANDLE hLogPal;          // handle to a logical palette
	LPSTR  lpbi;             // pointer to packed-DIB
	LPBITMAPINFO  lpbmi;     //pointer to BITMAPINFO structure
	int i;                   // loop index
	WORD wNumColors;         // number of colors in color table
	BOOL bResult = FALSE;

	if (hDIB == NULL)
	  return FALSE;

	wNumColors = MAX_COLORS;

	lpbi=(LPSTR) ::GlobalLock((HGLOBAL)hDIB);
	lpbmi=(LPBITMAPINFO)lpbi;
	/* allocate memory block for logical palette */
	hLogPal = ::GlobalAlloc(GHND, sizeof(LOGPALETTE)
				+ sizeof(PALETTEENTRY)* wNumColors);

	if (hLogPal == 0)
	{
		::GlobalUnlock((HGLOBAL) hDIB);
		return FALSE;
	}

	lpPal = (LPLOGPALETTE) ::GlobalLock((HGLOBAL) hLogPal);

	/* set version and number of palette entries */
	lpPal->palVersion = PALVERSION;
	lpPal->palNumEntries = (WORD)wNumColors;

	for(i=0;i<(int)wNumColors;i++)
	{
		lpPal->palPalEntry[i].peRed = lpbmi->bmiColors[i].rgbRed;
		lpPal->palPalEntry[i].peGreen = lpbmi->bmiColors[i].rgbGreen;
		lpPal->palPalEntry[i].peBlue = lpbmi->bmiColors[i].rgbBlue;
		lpPal->palPalEntry[i].peFlags = lpbmi->bmiColors[i].rgbReserved;
	}
		/* create the palette and get handle to it */
	bResult = pPal->CreatePalette(lpPal);
	::GlobalUnlock((HGLOBAL) hLogPal);
	::GlobalFree((HGLOBAL) hLogPal);

	::GlobalUnlock((HGLOBAL) hDIB);

	return bResult;
}


LPSTR WINAPI FindDIBBits(LPSTR lpbi)
{
	return (lpbi + *(LPDWORD)lpbi + MAX_COLORS * sizeof(RGBQUAD));
}


BOOL WINAPI PaintDIB(HDC   hDC,	LPRECT  lpDCRect,HDIB   hDIB,
					 LPRECT  lpDIBRect,	CPalette* pPal)
{
	LPSTR    lpDIBHdr;            // Pointer to BITMAPINFOHEADER
	LPSTR    lpDIBBits;           // Pointer to DIB bits
	BOOL     bSuccess=FALSE;      // Success/fail flag
	HPALETTE hPal=NULL;           // Our DIB's palette
	HPALETTE hOldPal=NULL;        // Previous palette

	/* Check for valid DIB handle */
	if (hDIB == NULL)
		return FALSE;

	// Lock down the DIB, and get a pointer to 
	// the beginning of the bit buffer
	
	lpDIBHdr  = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);
	lpDIBBits = ::FindDIBBits(lpDIBHdr);

	// Get the DIB's palette, then select it into DC
	if (pPal != NULL)
	{
		hPal = (HPALETTE) pPal->m_hObject;

		// Select as background since we have
		// already realized in forground if needed
		hOldPal = ::SelectPalette(hDC, hPal, TRUE);
		RealizePalette(hDC);
	}

	/* Make sure to use the stretching mode best for color pictures */
	::SetStretchBltMode(hDC, COLORONCOLOR);

	/* Determine whether to call StretchDIBits() or SetDIBitsToDevice() */
	if ((RECTWIDTH(lpDCRect)  == RECTWIDTH(lpDIBRect)) &&
	   (RECTHEIGHT(lpDCRect) == RECTHEIGHT(lpDIBRect)))
		bSuccess = ::SetDIBitsToDevice(hDC,        // hDC
	    		lpDCRect->left,  lpDCRect->top, // DestX,DestY
				RECTWIDTH(lpDCRect),RECTHEIGHT(lpDCRect),     // DestWidth, DestHeight
				lpDIBRect->left,lpDIBRect->top, // SrcX, SrcY
				RECTWIDTH(lpDIBRect),RECTHEIGHT(lpDIBRect),  // SrcWidth,SrcHeight
				lpDIBBits,                  // lpBits
				(LPBITMAPINFO)lpDIBHdr,     // lpBitsInfo
				DIB_RGB_COLORS);            // wUsage
   else
	  bSuccess = ::StretchDIBits(hDC,                          // hDC
				lpDCRect->left,lpDCRect->top,   // DestX, DestY
				RECTWIDTH(lpDCRect), RECTHEIGHT(lpDCRect), // DestWidth,DestHeight
				lpDIBRect->left, lpDIBRect->top, // SrcX,SrcY
				RECTWIDTH(lpDIBRect), RECTHEIGHT(lpDIBRect), // SrcWidth, SrcHeight
				lpDIBBits,                   // lpBits
				(LPBITMAPINFO)lpDIBHdr,         // lpBitsInfo
				DIB_RGB_COLORS,                 // wUsage
				SRCCOPY);                       // dwROP

   ::GlobalUnlock((HGLOBAL) hDIB);

	/* Reselect old palette */
	if (hOldPal != NULL)
		::SelectPalette(hDC, hOldPal, TRUE);

   return bSuccess;
}                     


HANDLE WINAPI appImgToDIB(CString FileName)
{   
	HANDLE          hdibCurrent;
									     
	DWORD           dw,ImgSize;
	BITMAPINFO FAR  *lpbmi = NULL;
	BITMAPFILEHEADER bHead;
	BITMAPINFOHEADER bi;

	BYTE             *lpData,*hp;
	int              i;

	BOOL  bOpen;
	CFile  cFile;
	
	bOpen=cFile.Open(FileName,CFile::modeRead | CFile::shareExclusive);
	if(bOpen==0) 
	{
		AfxMessageBox("Can't open the file!");
		return NULL;
	}
	cFile.Read(&bHead,sizeof(BITMAPFILEHEADER));
	cFile.Read(&bi,sizeof(BITMAPINFOHEADER));
	dw=sizeof(RGBQUAD)*MAX_COLORS+bi.biSize;
	
	ImgSize=dw+(bi.biWidth+3)/4*4*bi.biHeight*bi.biBitCount/8;
	Width=bi.biWidth;
	Height=bi.biHeight;

    hdibCurrent = GlobalAlloc (GMEM_MOVEABLE, ImgSize);
    if (!hdibCurrent) 
    {
	AfxMessageBox ("Error on global alloc!");
	goto ErrorExit;
    }
    lpData =(BYTE *) GlobalLock (hdibCurrent);

    lpbmi = (BITMAPINFO *)lpData;//GlobalLock (hdibCurrent);
    if (!lpbmi) 
    {
		AfxMessageBox ("Error on global lock!");
		goto ErrorExit;
    }
    lpbmi->bmiHeader = bi;    
				     
    if(!lpData)
    {
        AfxMessageBox("Error on locking hdataCurrent");
        return NULL;
    }

	for (i=0; i<MAX_COLORS; i++) 
	    cFile.Read(&(lpbmi->bmiColors[i]),4);
    
	hp = (BYTE  *)lpbmi + dw;	
	cFile.ReadHuge(hp,ImgSize);
	cFile.Close();
	  
	GlobalUnlock(hdibCurrent);
	return hdibCurrent;

ErrorExit:     
	GlobalUnlock(hdibCurrent);
	GlobalFree(hdibCurrent);
	return NULL;
}