dibapi.cpp

关于字符分割的程序

		//lpBMIH->biSize = SWAPLONG(lpBMIH->biSize);
		lpBMIH->biWidth = SWAPLONG(lpBMIH->biWidth);
		lpBMIH->biHeight = SWAPLONG(lpBMIH->biHeight);
		lpBMIH->biPlanes = SWAPWORD(lpBMIH->biPlanes);
		lpBMIH->biBitCount = SWAPWORD(lpBMIH->biBitCount);
		lpBMIH->biCompression = SWAPLONG(lpBMIH->biCompression);
		lpBMIH->biSizeImage = SWAPLONG(lpBMIH->biSizeImage);
		lpBMIH->biXPelsPerMeter = SWAPLONG(lpBMIH->biXPelsPerMeter);
		lpBMIH->biYPelsPerMeter = SWAPLONG(lpBMIH->biYPelsPerMeter);
		lpBMIH->biClrUsed = SWAPLONG(lpBMIH->biClrUsed);
		lpBMIH->biClrImportant = SWAPLONG(lpBMIH->biClrImportant);
	}
	else
	{
		LPBITMAPCOREHEADER lpBMCH = &(LPBITMAPCOREINFO(lpHeader)->bmciHeader);

		lpBMCH->bcWidth = SWAPWORD(lpBMCH->bcWidth);
		lpBMCH->bcHeight = SWAPWORD(lpBMCH->bcHeight);
		lpBMCH->bcPlanes = SWAPWORD(lpBMCH->bcPlanes);
		lpBMCH->bcBitCount = SWAPWORD(lpBMCH->bcBitCount);
	}
}

#endif

/*
20070403
*/
HPALETTE WINAPI CopyPalette(HPALETTE hPalSrc)
{
	int nNumEntries =0;
	PLOGPALETTE plogPal;
	HPALETTE  hPal;
	HANDLE     h;
	nNumEntries=GetPaletteEntries(hPalSrc,0,nNumEntries,NULL);
	if (0==nNumEntries) {
		return (HPALETTE)NULL;
	}
	h=GlobalAlloc(GHND,sizeof(DWORD)+sizeof(PALETTEENTRY)*nNumEntries );
	if (!h) {
		return (HPALETTE)NULL;
	}
	plogPal=(PLOGPALETTE)GlobalLock(h);

	if (!plogPal) {
		return (HPALETTE)NULL;
	}
	plogPal->palVersion=PALVERSION;
	plogPal->palNumEntries=(WORD)nNumEntries;
	GetPaletteEntries(hPalSrc,0,nNumEntries, plogPal->palPalEntry);
	hPal=CreatePalette(plogPal);
	GlobalUnlock(h);
	GlobalFree(h);
	return hPal;

}

HPALETTE WINAPI GetSystemPalette()
{
	HDC hDC;
	static HPALETTE hPal = NULL;
	LPLOGPALETTE lpLogPal;
	HANDLE hLogPal;
	int nColors;
	hDC=GetDC(NULL);
	if (hDC==NULL) {
		return NULL;
	}
	nColors=(1<<(GetDeviceCaps(hDC,BITSPIXEL)*GetDeviceCaps(hDC,PLANES) ));
	ASSERT(nColors);
	hLogPal=GlobalAlloc(GHND,sizeof(LPLOGPALETTE)+sizeof(PALETTEENTRY)*nColors );
	if (hLogPal==NULL) {
		return NULL;
	}
	lpLogPal=(LPLOGPALETTE)GlobalLock(hLogPal);
	lpLogPal->palVersion=PALVERSION;
	lpLogPal->palNumEntries=nColors;
	GetSystemPaletteEntries (hDC,0,nColors, lpLogPal->palPalEntry);
	hPal=CreatePalette(lpLogPal);
	GlobalUnlock(hLogPal);
	GlobalFree(hLogPal);
	ReleaseDC(NULL,hDC);
	return hPal;
}
HPALETTE WINAPI CreateIdentifyPalette(HPALETTE hPalSrc)
{
	int i,iSysColors,iPalEntries;
	HPALETTE hPalette,hpalOld;
	if (!hPalSrc) {
		return NULL;
	}
	hPalette=CopyPalette(hPalSrc);
	HDC hdcScreen = GetDC(NULL);
	ASSERT(hdcScreen);
	if (!(GetDeviceCaps(hdcScreen,RASTERCAPS)&RC_PALETTE) ){
		TRACE("Not a palettized device!");
		return NULL;
	}
	iSysColors=GetDeviceCaps(hdcScreen,NUMCOLORS);
	iPalEntries=GetDeviceCaps(hdcScreen,SIZEPALETTE);
	if (iSysColors>256) {
		::ReleaseDC(NULL,hdcScreen);
		return NULL;
	}
	SetSystemPaletteUse(hdcScreen,SYSPAL_NOSTATIC);
	SetSystemPaletteUse(hdcScreen,SYSPAL_STATIC);
	hpalOld=::SelectPalette(hdcScreen,hPalette,FALSE);
	::RealizePalette(hdcScreen);
	::SelectPalette(hdcScreen,hpalOld,FALSE);
	PALETTEENTRY pe[256];
	GetSystemPaletteEntries(hdcScreen,0,iPalEntries,pe);
	for (i=0;i<iSysColors/2;i++) {
		pe[i].peFlags=0;
	}
	for (;i<iPalEntries-iSysColors/2;i++) {
		pe[i].peFlags=PC_NOCOLLAPSE;
	}
	for (;i<iPalEntries;i++) {
		pe[i].peFlags=0;
	}
	ResizePalette(hPalette,iPalEntries);
	SetPaletteEntries(hPalette,0,iPalEntries,pe);
	::ReleaseDC(NULL,hdcScreen);
	return hPalette;

}

WORD     WINAPI DIBBitCount(LPSTR lpbi)
{
	WORD wBitCount;  // DIB bit count
	if (IS_WIN30_DIB(lpbi))
		wBitCount = ((LPBITMAPINFOHEADER)lpbi)->biBitCount;
	else
		wBitCount = ((LPBITMAPCOREHEADER)lpbi)->bcBitCount;
	return wBitCount;
}

/*************************************************************************
 *
 * 函数名称：
 *   ReadPCX256()
 *
 * 参数:
 *   CFile& file        - 要读取的文件
 *
 * 返回值:
 *   HDIB               - 成功返回DIB的句柄，否则返回NULL。
 *
 * 说明:
 *   该函数将读取指定的256色PCX文件。将读取的结果保存在一个未压缩
 * 编码的DIB对象中。
 *
 *************************************************************************/
HDIB WINAPI ReadPCX256(CFile& file)
{
	// PCX文件头
	PCXHEADER pcxHdr;
	
	// DIB大小（字节数）
	DWORD	dwDIBSize;
	
	// DIB句柄
	HDIB	hDIB;
	
	// DIB指针
	LPSTR	pDIB;
	
	// 循环变量
	LONG	i;
	LONG	j;
	
	// 重复像素计数
	int		iCount;
	
	// DIB高度
	WORD	wHeight;
	
	// DIB宽度
	WORD	wWidth;
	
	// 图像每行的字节数
	LONG	lLineBytes;
	
	// 中间变量
	BYTE	bChar;
	
	// 指向源图像象素的指针
	BYTE *	lpSrc;
	
	// 指向编码后图像数据的指针
	BYTE *	lpDst;
	
	// 临时指针
	BYTE *	lpTemp;
	
	// 尝试读取PCX文件头
	if (file.Read((LPSTR)&pcxHdr, sizeof(PCXHEADER)) != sizeof(PCXHEADER))
	{
		// 大小不对，返回NULL。
		return NULL;
	}
	
	// 判断是否是256色PCX文件，检查第一个字节是否是0x0A，
	if ((pcxHdr.bManufacturer != 0x0A) || (pcxHdr.bBpp != 8) || (pcxHdr.bPlanes != 1))
	{
		// 非256色PCX文件，返回NULL。
		return NULL;
	}
	
	// 获取图像高度
	wHeight = pcxHdr.wBottom - pcxHdr.wTop + 1;
	
	// 获取图像宽度
	wWidth  = pcxHdr.wRight - pcxHdr.wLeft + 1;
	
	// 计算图像每行的字节数
	lLineBytes = WIDTHBYTES(wWidth * 8);
	
	// 计算DIB长度（字节）
	dwDIBSize = sizeof(BITMAPINFOHEADER) + 1024 + wHeight * lLineBytes;
	
	// 为DIB分配内存
	hDIB = (HDIB) ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, dwDIBSize);
	if (hDIB == 0)
	{
		// 内存分配失败，返回NULL。
		return NULL;
	}
	
	// 锁定
	pDIB = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);
	
	// 指向BITMAPINFOHEADER的指针
	LPBITMAPINFOHEADER lpBI;
	
	// 赋值
	lpBI = (LPBITMAPINFOHEADER) pDIB;
	
	// 给lpBI成员赋值
	lpBI->biSize = 40;
	lpBI->biWidth = wWidth;
	lpBI->biHeight = wHeight;
	lpBI->biPlanes = 1;
	lpBI->biBitCount = 8;
	lpBI->biCompression = BI_RGB;
	lpBI->biSizeImage = wHeight * lLineBytes;
	lpBI->biXPelsPerMeter = pcxHdr.wXResolution;
	lpBI->biYPelsPerMeter = pcxHdr.wYResolution;
	lpBI->biClrUsed = 0;
	lpBI->biClrImportant = 0;
	
	// 分配内存以读取编码后的象素
	lpSrc = new BYTE[file.GetLength() - sizeof(PCXHEADER) - 769];
	lpTemp = lpSrc;
	
	// 读取编码后的象素
	if (file.ReadHuge(lpSrc, file.GetLength() - sizeof(PCXHEADER) - 769) !=
		file.GetLength() - sizeof(PCXHEADER) - 769 )
	{
		// 大小不对。
		
		// 解除锁定
		::GlobalUnlock((HGLOBAL) hDIB);
		
		// 释放内存
		::GlobalFree((HGLOBAL) hDIB);
		
		// 返回NULL。
		return NULL;
	}
	
	// 计算DIB中像素位置
	lpDst = (BYTE *) FindDIBBits(pDIB);
	
	// 一行一行解码
	for (j = 0; j <wHeight; j++)
	{
		i = 0;
		while (i < wWidth)
		{
			// 读取一个字节
			bChar = *lpTemp;
			lpTemp++;
			
			if ((bChar & 0xC0) == 0xC0)
			{
				// 行程
				iCount = bChar & 0x3F;
				
				// 读取下一个字节
				bChar = *lpTemp;
				lpTemp++;
				
				// bChar重复iCount次保存
				memset(&lpDst[(wHeight - j - 1) * lLineBytes + i], bChar, iCount);

				// 已经读取像素的个数加iCount
				i += iCount;
			}
			else
			{
				// 保存当前字节
				lpDst[(wHeight - j - 1) * lLineBytes + i] = bChar;
				
				// 已经读取像素的个数加1
				i += 1;
			}
		}
	}
	
	// 释放内存
	delete lpSrc;
	
	//*************************************************************
	// 调色板
	
	// 读调色板标志位
	file.Read(&bChar, 1);
	if (bChar != 0x0C)
	{
		// 出错
		
		// 解除锁定
		::GlobalUnlock((HGLOBAL) hDIB);
		
		// 释放内存
		::GlobalFree((HGLOBAL) hDIB);
		
		// 返回NULL。
		return NULL;
	}
	
	// 分配内存以读取编码后的象素
	lpSrc = new BYTE[768];
	
	// 计算DIB中调色板的位置
	lpDst = (BYTE *) pDIB + sizeof(BITMAPINFOHEADER);
	
	// 读取调色板
	if (file.Read(lpSrc, 768) != 768)
	{
		// 大小不对。
		
		// 解除锁定
		::GlobalUnlock((HGLOBAL) hDIB);
		
		// 释放内存
		::GlobalFree((HGLOBAL) hDIB);
		
		// 返回NULL。
		return NULL;
	}
	
	// 给调色板赋值
	for (i = 0; i < 256; i++)
	{
		lpDst[i * 4] = lpSrc[i * 3 + 2];
		lpDst[i * 4 + 1] = lpSrc[i * 3 + 1];
		lpDst[i * 4 + 2] = lpSrc[i * 3];
		lpDst[i * 4 + 3] = 0;
	}
	
	// 释放内存
	delete lpSrc;
	
	// 解除锁定
	::GlobalUnlock((HGLOBAL) hDIB);
	
	// 返回DIB句柄
	return hDIB;
}



WORD     WINAPI filestyle(CFile & file)
{
	// GIF文件头
	GIFHEADER          GIFH;
	BITMAPFILEHEADER bmfHeader;
	PCXHEADER pcxHdr;

	if (file.Read((LPSTR)&bmfHeader, sizeof(bmfHeader)) != sizeof(bmfHeader))
		return 0;
	if (bmfHeader.bfType == DIB_HEADER_MARKER)
	{	return 1;	}
	else
	{
		file.SeekToBegin();
		file.Read((LPSTR)&GIFH, sizeof(GIFH));
		if (memicmp((LPSTR)GIFH.bySignature,"GIF",3) == 0)   //是否是GIF文件
		{return 2;		}
		else
		{
			file.SeekToBegin();
			file.Read((LPSTR)&pcxHdr, sizeof(PCXHEADER)) ;
			// 判断是否是256色PCX文件，检查第一个字节是否是0x0A，
			if ((pcxHdr.bManufacturer == 0x0A) && (pcxHdr.bBpp == 8) && (pcxHdr.bPlanes == 1))
			{ return 3;}
			else
			{
				return 0;
			}
		}
	}
	
}