bitmap解码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define BYTE unsigned char
#define WORD short
#define DWORD long

#define SUCCESS 0
#define FAILURE 0xFFFFFFFF
#define VOID void

#define CHECK_NULL_POINT(x) { if(NULL == (x)) return FAILURE;}
#define CHECK_NULL_RETURN(x) { if(0 == (x)) return FAILURE; }
#define CHECK_FALSE_RETURN(x) { if(!(x)) return FAILURE; }
#define CHECK_FAIL_RETURN(x) { if(FAILURE == (x)) return FAILURE; }
#define GET_RGB_QUAD_SIZE(x) (1 == (x) ? 2 : (4 == (x) ? 16 : (8 == (x) ? 256 : (16 == (x) ? 65536 : 0))))

#define LOG_ERR(format, ...) do { printf("[ ERR ]: "); printf(format, ##__VA_ARGS__); } while (0)
#define LOG_DBG(format, ...) do { printf("[ DBG ]: "); printf(format, ##__VA_ARGS__); } while (0)
#define LOG_INF(format, ...) do { printf("[ INF ]: "); printf(format, ##__VA_ARGS__); } while (0)

typedef struct tagBitmapFileHeader
{
	WORD bfAlign; //字节对齐
	WORD bfType;//位图文件的类型，必须为BM(1-2字节）
	DWORD bfSize;//位图文件的大小，以字节为单位（3-6字节，低位在前）
	WORD bfReserved1;//位图文件保留字，必须为0(7-8字节）
	WORD bfReserved2;//位图文件保留字，必须为0(9-10字节）
	DWORD bfOffBits;//位图数据的起始位置，以相对于位图（11-14字节，低位在前）
	//文件头的偏移量表示，以字节为单位
}BitmapFileHeader;

typedef struct tagBitmapInfoHeader{
	DWORD biSize;//本结构所占用字节数（15-18字节）
	DWORD biWidth;//位图的宽度，以像素为单位（19-22字节）
	DWORD biHeight;//位图的高度，以像素为单位（23-26字节）
	WORD biPlanes;//目标设备的级别，必须为1(27-28字节）
	WORD biBitCount;//每个像素所需的位数，必须是1（双色），（29-30字节）
	//4(16色），8(256色）16(高彩色)或24（真彩色）之一
	DWORD biCompression;//位图压缩类型，必须是0（不压缩），（31-34字节）
	//1(BI_RLE8压缩类型）或2(BI_RLE4压缩类型）之一
	DWORD biSizeImage;//位图的大小(其中包含了为了补齐行数是4的倍数而添加的空字节)，以字节为单位（35-38字节）
	DWORD biXPelsPerMeter;//位图水平分辨率，每米像素数（39-42字节）
	DWORD biYPelsPerMeter;//位图垂直分辨率，每米像素数（43-46字节)
	DWORD biClrUsed;//位图实际使用的颜色表中的颜色数（47-50字节）
	DWORD biClrImportant;//位图显示过程中重要的颜色数（51-54字节）
}BitmapInfoHeader;
/**
 * 	当biBitCount = 1, 4, 8时，分别有2, 16, 256个表项；
 *	当biBitCount = 24时，没有颜色表项。
 */
typedef struct tagRgbQuad{
	BYTE rgbBlue;//蓝色的亮度（值范围为0-255)
	BYTE rgbGreen;//绿色的亮度（值范围为0-255)
	BYTE rgbRed;//红色的亮度（值范围为0-255)
	BYTE rgbReserved;//保留，必须为0
}RgbQuad;

typedef struct tagBitmapInfo{
	BitmapInfoHeader biInfoHeader;//位图信息头
	RgbQuad *rgbQuad; //颜色表
	WORD rgbQuadSize; // 颜色表大小
}BitmapInfo;

typedef struct tagBitmapHandle{
	BitmapFileHeader biFileHeader; // 文件头
	BitmapInfo biInfo; // 位图信息头 + 颜色表
	BYTE **bPixelMatrix; // 像素矩阵
}BitmapHandle;

DWORD InitBitmapHandle(BitmapHandle *biHandle)
{
	CHECK_NULL_POINT(biHandle);
	memset(biHandle, 0, sizeof(BitmapHandle));

	return SUCCESS;
}

DWORD CheckBitmapFileHeader(BitmapFileHeader *biFileHeader)
{
	CHECK_NULL_POINT(biFileHeader);
	CHECK_FALSE_RETURN(0x4D42 == biFileHeader->bfType);
	return SUCCESS;
}

DWORD CheckBitmapInfoHeader(BitmapInfoHeader *biInfoHeader)
{
	WORD biBitCount;
	CHECK_NULL_POINT(biInfoHeader);
	CHECK_FALSE_RETURN(1 == biInfoHeader->biPlanes);
	biBitCount = biInfoHeader->biBitCount;
	CHECK_FALSE_RETURN(1 == biBitCount || 4 == biBitCount || 8 == biBitCount
		|| 16 == biBitCount || 24 == biBitCount);
	CHECK_FALSE_RETURN(0 == biInfoHeader->biCompression);
	return SUCCESS;
}

DWORD ReadBmpInfo(FILE *pBmpFile, BitmapHandle *biHandle)
{
	DWORD dRet;
	BitmapFileHeader *biFileHeader;
	BitmapInfo *biInfo;
	BitmapInfoHeader *biInfoHeader;

	LOG_DBG("....start ReadBmpInfo....\n");
	CHECK_NULL_POINT(pBmpFile);
	CHECK_NULL_POINT(biHandle);

	biFileHeader = &biHandle->biFileHeader;
	biInfo = &biHandle->biInfo;
	biInfoHeader = &biInfo->biInfoHeader;

	dRet = fread(&biFileHeader->bfType, sizeof(BitmapFileHeader)-sizeof(WORD), 1, pBmpFile);
	CHECK_NULL_RETURN(dRet);
	LOG_DBG("ReadBmpInfo: read bitmap file header success!\n");
	dRet = CheckBitmapFileHeader(biFileHeader);
	CHECK_FAIL_RETURN(dRet);
	LOG_DBG("ReadBmpInfo: check bitmap file header success!\n");

	dRet = fread(biInfoHeader, sizeof(BitmapInfoHeader), 1, pBmpFile);
	CHECK_NULL_RETURN(dRet);
	LOG_DBG("ReadBmpInfo: read bitmap info header success!\n");
	dRet = CheckBitmapInfoHeader(biInfoHeader);
	CHECK_FAIL_RETURN(dRet);
	LOG_DBG("ReadBmpInfo: check bitmap info header success!\n");

	biInfo->rgbQuadSize = GET_RGB_QUAD_SIZE(biInfoHeader->biBitCount);
	biInfo->rgbQuad = (biInfo->rgbQuadSize == 0) ? NULL : ((RgbQuad*)malloc(biInfo->rgbQuadSize*sizeof(RgbQuad)));
	CHECK_NULL_POINT(biInfo->rgbQuad);
	LOG_DBG("ReadBmpInfo: start read RGB quad...\n");
	dRet = fread(biInfo->rgbQuad, sizeof(RgbQuad), biInfo->rgbQuadSize, pBmpFile);
	CHECK_FAIL_RETURN(dRet);
	LOG_DBG("ReadBmpInfo: read RGB quad success!\n");
	LOG_DBG("....end ReadBmpInfo....\n");

	return SUCCESS;
}

DWORD ReadBmpData(FILE *pBmpFile, BitmapHandle *biHandle)
{
	DWORD biWidth;
	DWORD biHeight;
	WORD biBitCount;
	DWORD dwRowBits;
	DWORD dwRowBytes;
	WORD loop;
	BYTE *buff;
	DWORD dRet;
	BitmapInfo *biInfo;
	BitmapInfoHeader *biInfoHeader;

	LOG_DBG("....start ReadBmpData....\n");
	CHECK_NULL_POINT(pBmpFile);
	CHECK_NULL_POINT(biHandle);

	biInfo = &biHandle->biInfo;
	CHECK_NULL_POINT(biInfo);
	biInfoHeader = &biHandle->biInfo.biInfoHeader;
	CHECK_NULL_POINT(biInfoHeader);

	biWidth = biInfoHeader->biWidth;
	biHeight = biInfoHeader->biHeight;
	biBitCount = biInfoHeader->biBitCount;
	dwRowBits = biWidth * biBitCount;

	dwRowBytes = dwRowBits >> 3 + ((dwRowBits & 0x7) == 0 ? 0 : 1); // dwRowBits / 8 + (dwRowBits % 8 == 0 ? 0 : 1)
	dwRowBytes = dwRowBytes + ((4 - (dwRowBytes & 0x3))  & 0x3); // dwRowBytes + (4 - dwRowBytes % 4) % 4

	buff = (BYTE*)malloc(dwRowBytes*biHeight*sizeof(BYTE));
	CHECK_NULL_POINT(buff);
	LOG_DBG("ReadBmpData: alloc buff for pixel matrix success!\n");
	LOG_DBG("ReadBmpData: Width|%d,RowBytes|%d,Height|%d,Size|%d\n", biWidth, dwRowBytes, biHeight, dwRowBytes*biHeight);

	dRet = fread(buff, dwRowBytes, biHeight, pBmpFile);
	CHECK_NULL_RETURN(dRet);
	LOG_DBG("ReadBmpData: read pixel matrix success! dRet|%d\n", dRet);

	biHandle->bPixelMatrix = (BYTE**)malloc(biHeight*sizeof(BYTE*));
	CHECK_NULL_POINT(biHandle->bPixelMatrix);

	for(loop = 0; loop < biHeight; loop++)
	{
		biHandle->bPixelMatrix[loop] = &buff[loop*dwRowBytes];
	}

	LOG_DBG("....end ReadBmpData....\n");

	return SUCCESS;
}

DWORD ReleaseBmpSpace(BitmapHandle *biHandle)
{
	LOG_DBG("....start ReleaseBmpSpace....\n");
	CHECK_NULL_POINT(biHandle);

	if(biHandle->biInfo.rgbQuad != NULL) free(biHandle->biInfo.rgbQuad);
	if(biHandle->bPixelMatrix != NULL)
	{
		if(biHandle->bPixelMatrix[0] != NULL)
			free(biHandle->bPixelMatrix[0]);
		free(biHandle->bPixelMatrix);
	}
//	free(biHandle);
	LOG_DBG("....end ReleaseBmpSpace....\n");

	return SUCCESS;
}

DWORD LogBmpInfo(BitmapHandle *biHandle)
{
	BitmapFileHeader *biFileHeader;
	BitmapInfo *biInfo;
	BitmapInfoHeader *biInfoHeader;
	RgbQuad * rgbQuad;

	CHECK_NULL_POINT(biHandle);
	biFileHeader = &biHandle->biFileHeader;
	biInfo = &biHandle->biInfo;
	biInfoHeader = &biInfo->biInfoHeader;
	rgbQuad = biInfo->rgbQuad;

	LOG_INF("BitmapFileHeader: Type|%x,Size|%d,Offset|%d\n",biFileHeader->bfType, biFileHeader->bfSize, biFileHeader->bfOffBits);
	LOG_INF("BitmapInfoHeader: Size|%d,Width|%d,Height|%d,Planes|%d,BitCount|%d,Compression|%d\n",
		biInfoHeader->biSize,biInfoHeader->biWidth,biInfoHeader->biHeight,biInfoHeader->biPlanes,biInfoHeader->biBitCount,biInfoHeader->biCompression);
	LOG_INF("BitmapInfoHeader: SizeImage|%d,XPelsPerM|%d,YPelsPerM|%d,ClrUsed|%d,ClrImportant|%d\n",
		biInfoHeader->biSizeImage,biInfoHeader->biXPelsPerMeter,biInfoHeader->biYPelsPerMeter,biInfoHeader->biClrUsed,biInfoHeader->biClrImportant);
	LOG_INF("RgbQuad: %d\n", (rgbQuad == NULL ? 0 : sizeof(rgbQuad)/sizeof(RgbQuad)));

	return SUCCESS;
}

int main(int argc, char *argv[])
{
	FILE *pBmpFile;
	BitmapHandle biHandle;
/*
	printf("short:%d\n", sizeof(short));
	printf("long: %d\n", sizeof(long));
	printf("BitmapFileHeader:%d\n", sizeof(BitmapFileHeader));
	printf("BitmapInfoHeader:%d\n", sizeof(BitmapInfoHeader));
	printf("RgbQuad:%d\n", sizeof(RgbQuad));
	DWORD dwRowBits;
	DWORD dwRowBytes;
	dwRowBits = 8448;
	dwRowBytes = (dwRowBits & 0x7 == 0 ? 0 : 1) + (dwRowBits >> 3);
	printf("dwRowBytes:%d,%d\n", ((dwRowBits & 0x7) == 0 ? 0 : 1), (dwRowBits >> 3));
	system("pause");
	*/
//	CHECK_FAIL_RETURN(2 == argc);
//	pBmpFile = fopen(argv[1], "rb");
	pBmpFile = fopen("C:\\Users\\10207695\\Documents\\Visual Studio 2010\\Projects\\desp\\Debug\\01.bmp", "rb");

	CHECK_NULL_POINT(pBmpFile);
	LOG_DBG("Main: open bitmap file success!\n");

	ReadBmpInfo(pBmpFile, &biHandle);
	ReadBmpData(pBmpFile, &biHandle);
	fclose(pBmpFile);

	LogBmpInfo(&biHandle);

	system("pause");

	ReleaseBmpSpace(&biHandle);
	return 0;
}