#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;

}