2 4 8位BMP转24位BMP（代码）

//#include "stdafx.h"
#include <math.h>
#define WIDTHBYTE(bit)   ((  ( (bit)+31)/32 )*4)
#define _BITS_PER_PIXEL_24	24
BOOL ConvertBmp4ToBmp24(const char* pSrcFile,const char* pDesFile)
{
FILE* fpSrc = fopen(pSrcFile,"rb");
if(fpSrc == NULL) return FALSE;

// Read BITMAPFILEHEADER info
BITMAPFILEHEADER bfh;
fread(&bfh, 1, sizeof(BITMAPFILEHEADER), fpSrc);

// Read BITMAPINFOHEADER info
BITMAPINFOHEADER bih;
fread(&bih, 1, sizeof(BITMAPINFOHEADER), fpSrc);

const int iPitch = WIDTHBYTE(bih.biBitCount*bih.biWidth);

if(bih.biBitCount == 4) //16 色
{
//转换为 24 位
long _bpp = (_BITS_PER_PIXEL_24 >> 3);
long _pitch = bih.biWidth * _bpp;
while ((_pitch & 3) != 0)
_pitch++;

FILE* fpDes = fopen(pDesFile,"wb");
if(fpDes == NULL)
{
fclose(fpSrc);
return FALSE;
}
//24 bmp header
BITMAPFILEHEADER bfh24 = bfh;
BITMAPINFOHEADER bih24 = bih;
DWORD dwSize = _pitch * bih.biHeight;
bfh24.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + dwSize;
bfh24.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
bih24.biBitCount = _BITS_PER_PIXEL_24;
fwrite(&bfh24,sizeof(BITMAPFILEHEADER),1,fpDes);
fwrite(&bih24,sizeof(BITMAPINFOHEADER),1,fpDes);
//end

// Calculate palette entries
int  iPaletteEntries = bih.biClrUsed;
if (iPaletteEntries == 0)
iPaletteEntries = 16;

RGBQUAD lpPalette[256] = {0};
// Read palette info
fread(lpPalette, iPaletteEntries, sizeof(RGBQUAD), fpSrc);

//Progress
// 		CProgressDlg dlg;//进度条
// 		dlg.Create();
// 		dlg.SetStep(1);
// 		dlg.SetPos(0);
// 		dlg.SetWindowText(_T("位图格式转换中..."));
//分批读取数据 200 row
const int oncerow = 200;
const int times = bih.biHeight/oncerow;
for(int i = 0;i<times;i++) //需要处理多少次
{
//dlg.SetPos( (1.0*i/times)*100);
const DWORD dwSize = iPitch * oncerow;
LPBYTE lpData = (LPBYTE)malloc(dwSize*sizeof(BYTE));
fread(lpData, dwSize, sizeof(BYTE), fpSrc);

// Create temporary bitmap
const DWORD dw24Size = _pitch * oncerow;
LPBYTE lp24Data = (LPBYTE)malloc(dw24Size*sizeof(BYTE));

// Convert bitmap
DWORD dwDstHorizontalOffset;
DWORD dwDstVerticalOffset = 0;
DWORD dwDstTotalOffset;

DWORD dwSrcHorizontalOffset;
DWORD dwSrcVerticalOffset = 0;
DWORD dwSrcTotalOffset;

for (long i=0; i<oncerow; i++) //每次转换 200 行
{
dwDstHorizontalOffset = 0;
dwSrcHorizontalOffset = 0;
for (long j=0; j<bih.biWidth; j++) //像素个数
{
// Update destination total offset
dwDstTotalOffset = dwDstVerticalOffset + dwDstHorizontalOffset;

// Update source total offset
dwSrcTotalOffset = dwSrcVerticalOffset + dwSrcHorizontalOffset;

//lpData[dwSrcTotalOffset]
//第 j 个像素点
//const int bitoffidx = 7 - j%8; //前 4 个字节的值
//const int opreatenum = pow(2,bitoffidx);
//int statevalue = (lpData[dwSrcTotalOffset]&opreatenum) >> bitoffidx;
int statevalue = 0;
if(j%2 == 0)
{
statevalue = (lpData[dwSrcTotalOffset] & 0xf0) >> 4;
}
else
{
statevalue = lpData[dwSrcTotalOffset] & 0x0f;
}

BYTE red = lpPalette[statevalue].rgbRed;
BYTE green = lpPalette[statevalue].rgbGreen;
BYTE blue = lpPalette[statevalue].rgbBlue;

// Update bitmap
lp24Data[dwDstTotalOffset+2] = red;
lp24Data[dwDstTotalOffset+1] = green;
lp24Data[dwDstTotalOffset] = blue;

// Update destination horizontal offset
dwDstHorizontalOffset += _bpp;

// Update source horizontal offset
dwSrcHorizontalOffset = (j+1)/2;
}

// Update destination vertical offset
dwDstVerticalOffset += _pitch;

// Update source vertical offset
dwSrcVerticalOffset += iPitch;
}
fwrite(lp24Data,sizeof(BYTE),dw24Size,fpDes);
delete[]  lp24Data;
}
//剩余不够 200 行的
const int leftrow  = bih.biHeight%oncerow;
//dlg.SetPos(100);
if(leftrow > 0)
{

const DWORD dwSize = iPitch * leftrow;
LPBYTE lpData = (LPBYTE)malloc(dwSize*sizeof(BYTE));
fread(lpData, dwSize, sizeof(BYTE), fpSrc);

// Create temporary bitmap
const DWORD dw24Size = _pitch * leftrow;
LPBYTE lp24Data = (LPBYTE)malloc(dw24Size*sizeof(BYTE));

// Convert bitmap
DWORD dwDstHorizontalOffset;
DWORD dwDstVerticalOffset = 0;
DWORD dwDstTotalOffset;

DWORD dwSrcHorizontalOffset;
DWORD dwSrcVerticalOffset = 0;
DWORD dwSrcTotalOffset;

for (long i=0; i<leftrow; i++) //每次转换 200 行
{
dwDstHorizontalOffset = 0;
dwSrcHorizontalOffset = 0;
for (long j=0; j<bih.biWidth; j++)
{
// Update destination total offset
dwDstTotalOffset = dwDstVerticalOffset + dwDstHorizontalOffset;

// Update source total offset
dwSrcTotalOffset = dwSrcVerticalOffset + dwSrcHorizontalOffset;

//star
//const int bitoffidx = 7-j%8;
//const int opreatenum = pow(2,bitoffidx);
//int statevalue = (lpData[dwSrcTotalOffset]&opreatenum) >> bitoffidx;
int statevalue = 0;
if(j%2 == 0)
{
statevalue = (lpData[dwSrcTotalOffset] & 0xf0) >> 4;
}
else
{
statevalue = lpData[dwSrcTotalOffset] & 0x0f;
}

BYTE red = lpPalette[statevalue].rgbRed;
BYTE green = lpPalette[statevalue].rgbGreen;
BYTE blue = lpPalette[statevalue].rgbBlue;
//end

// Update bitmap
lp24Data[dwDstTotalOffset+2] = red;
lp24Data[dwDstTotalOffset+1] = green;
lp24Data[dwDstTotalOffset] = blue;

// Update destination horizontal offset
dwDstHorizontalOffset += _bpp;

// Update source horizontal offset
dwSrcHorizontalOffset = (j+1)/2;
}

// Update destination vertical offset
dwDstVerticalOffset += _pitch;

// Update source vertical offset
dwSrcVerticalOffset += iPitch;
}
fwrite(lp24Data,sizeof(BYTE),dw24Size,fpDes);
delete[]  lp24Data;
}
fclose(fpSrc);
fclose(fpDes);
return TRUE;

}
else
{
fclose(fpSrc);
return FALSE;
}
}
BOOL ConvertBmp1ToBmp24(const char* pSrcFile,const char* pDesFile)
{
FILE* fpSrc = fopen(pSrcFile,"rb");
if(fpSrc == NULL) return FALSE;

// Read BITMAPFILEHEADER info
BITMAPFILEHEADER bfh;
fread(&bfh, 1, sizeof(BITMAPFILEHEADER), fpSrc);

// Read BITMAPINFOHEADER info
BITMAPINFOHEADER bih;
fread(&bih, 1, sizeof(BITMAPINFOHEADER), fpSrc);

const int iPitch = WIDTHBYTE(bih.biBitCount*bih.biWidth);

if(bih.biBitCount == 1) //黑白图
{
//转换为 24 位
long _bpp = (_BITS_PER_PIXEL_24 >> 3);
long _pitch = bih.biWidth * _bpp;
while ((_pitch & 3) != 0)
_pitch++;

FILE* fpDes = fopen(pDesFile,"wb");
if(fpDes == NULL)
{
fclose(fpSrc);
return FALSE;
}
//24 bmp header
BITMAPFILEHEADER bfh24 = bfh;
BITMAPINFOHEADER bih24 = bih;
DWORD dwSize = _pitch * bih.biHeight;
bfh24.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + dwSize;
bfh24.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
bih24.biBitCount = _BITS_PER_PIXEL_24;
fwrite(&bfh24,sizeof(BITMAPFILEHEADER),1,fpDes);
fwrite(&bih24,sizeof(BITMAPINFOHEADER),1,fpDes);
//end

// Calculate palette entries
int  iPaletteEntries = bih.biClrUsed;
if (iPaletteEntries == 0)
iPaletteEntries = 2;

RGBQUAD lpPalette[256] = {0};
// Read palette info
fread(lpPalette, iPaletteEntries, sizeof(RGBQUAD), fpSrc);

// 		//Progress
// 		CProgressDlg dlg;//进度条
// 		dlg.Create();
// 		dlg.SetStep(1);
// 		dlg.SetPos(0);
// 		dlg.SetWindowText(_T("位图格式转换中..."));
//分批读取数据 200 row
const int oncerow = 200;
const int times = bih.biHeight/oncerow;
for(int i = 0;i<times;i++) //需要处理多少次
{
//dlg.SetPos( (1.0*i/times)*100);
const DWORD dwSize = iPitch * oncerow;
LPBYTE lpData = (LPBYTE)malloc(dwSize*sizeof(BYTE));
fread(lpData, dwSize, sizeof(BYTE), fpSrc);

// Create temporary bitmap
const DWORD dw24Size = _pitch * oncerow;
LPBYTE lp24Data = (LPBYTE)malloc(dw24Size*sizeof(BYTE));

// Convert bitmap
DWORD dwDstHorizontalOffset;
DWORD dwDstVerticalOffset = 0;
DWORD dwDstTotalOffset;

DWORD dwSrcHorizontalOffset;
DWORD dwSrcVerticalOffset = 0;
DWORD dwSrcTotalOffset;

for (long i=0; i<oncerow; i++) //每次转换 200 行
{
dwDstHorizontalOffset = 0;
dwSrcHorizontalOffset = 0;
for (long j=0; j<bih.biWidth; j++) //像素个数
{
// Update destination total offset
dwDstTotalOffset = dwDstVerticalOffset + dwDstHorizontalOffset;

// Update source total offset
dwSrcTotalOffset = dwSrcVerticalOffset + dwSrcHorizontalOffset;

//lpData[dwSrcTotalOffset]
//第 j 个像素点
const int bitoffidx = 7 - j%8;
const int opreatenum = pow(2,bitoffidx);
int statevalue = (lpData[dwSrcTotalOffset]&opreatenum) >> bitoffidx;

BYTE red = lpPalette[statevalue].rgbRed;
BYTE green = lpPalette[statevalue].rgbGreen;
BYTE blue = lpPalette[statevalue].rgbBlue;

// Update bitmap
lp24Data[dwDstTotalOffset+2] = red;
lp24Data[dwDstTotalOffset+1] = green;
lp24Data[dwDstTotalOffset] = blue;

// Update destination horizontal offset
dwDstHorizontalOffset += _bpp;

// Update source horizontal offset
dwSrcHorizontalOffset = (j+1)/8;
}

// Update destination vertical offset
dwDstVerticalOffset += _pitch;

// Update source vertical offset
dwSrcVerticalOffset += iPitch;
}
fwrite(lp24Data,sizeof(BYTE),dw24Size,fpDes);
delete[]  lp24Data;
}
//剩余不够 200 行的
const int leftrow  = bih.biHeight%oncerow;
//dlg.SetPos(100);
if(leftrow > 0)
{

const DWORD dwSize = iPitch * leftrow;
LPBYTE lpData = (LPBYTE)malloc(dwSize*sizeof(BYTE));
fread(lpData, dwSize, sizeof(BYTE), fpSrc);

// Create temporary bitmap
const DWORD dw24Size = _pitch * leftrow;
LPBYTE lp24Data = (LPBYTE)malloc(dw24Size*sizeof(BYTE));

// Convert bitmap
DWORD dwDstHorizontalOffset;
DWORD dwDstVerticalOffset = 0;
DWORD dwDstTotalOffset;

DWORD dwSrcHorizontalOffset;
DWORD dwSrcVerticalOffset = 0;
DWORD dwSrcTotalOffset;

for (long i=0; i<leftrow; i++) //每次转换 200 行
{
dwDstHorizontalOffset = 0;
dwSrcHorizontalOffset = 0;
for (long j=0; j<bih.biWidth; j++)
{
// Update destination total offset
dwDstTotalOffset = dwDstVerticalOffset + dwDstHorizontalOffset;

// Update source total offset
dwSrcTotalOffset = dwSrcVerticalOffset + dwSrcHorizontalOffset;

//star
const int bitoffidx = 7-j%8;
const int opreatenum = pow(2,bitoffidx);
int statevalue = (lpData[dwSrcTotalOffset]&opreatenum) >> bitoffidx;

BYTE red = lpPalette[statevalue].rgbRed;
BYTE green = lpPalette[statevalue].rgbGreen;
BYTE blue = lpPalette[statevalue].rgbBlue;
//end

// Update bitmap
lp24Data[dwDstTotalOffset+2] = red;
lp24Data[dwDstTotalOffset+1] = green;
lp24Data[dwDstTotalOffset] = blue;

// Update destination horizontal offset
dwDstHorizontalOffset += _bpp;

// Update source horizontal offset
dwSrcHorizontalOffset = (j+1)/8;
}

// Update destination vertical offset
dwDstVerticalOffset += _pitch;

// Update source vertical offset
dwSrcVerticalOffset += iPitch;
}
fwrite(lp24Data,sizeof(BYTE),dw24Size,fpDes);
delete[]  lp24Data;
}
fclose(fpSrc);
fclose(fpDes);
return TRUE;

}
else
{
fclose(fpSrc);
return FALSE;
}
}
BOOL ConvertBmp8ToBmp24(const char* pSrcFile,const char* pDesFile)
{
FILE* fpSrc = fopen(pSrcFile,"rb");
if(fpSrc == NULL) return FALSE;

// Read BITMAPFILEHEADER info
BITMAPFILEHEADER bfh;
fread(&bfh, 1, sizeof(BITMAPFILEHEADER), fpSrc);

// Read BITMAPINFOHEADER info
BITMAPINFOHEADER bih;
fread(&bih, 1, sizeof(BITMAPINFOHEADER), fpSrc);

// Calculate pitch
const int iBpp = bih.biBitCount >> 3;
int iPitch = iBpp * bih.biWidth;
while ((iPitch & 3) != 0)
iPitch++;
if (bih.biBitCount == 8)
{
//转换为 24 位
long _bpp = (_BITS_PER_PIXEL_24 >> 3);
long _pitch = bih.biWidth * _bpp;
while ((_pitch & 3) != 0)
_pitch++;

FILE* fpDes = fopen(pDesFile,"wb");
if(fpDes == NULL)
{
fclose(fpSrc);
return FALSE;
}
//24 bmp header
BITMAPFILEHEADER bfh24 = bfh;
BITMAPINFOHEADER bih24 = bih;
DWORD dwSize = _pitch * bih.biHeight;
bfh24.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + dwSize;
bfh24.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
bih24.biBitCount = _BITS_PER_PIXEL_24;
fwrite(&bfh24,sizeof(BITMAPFILEHEADER),1,fpDes);
fwrite(&bih24,sizeof(BITMAPINFOHEADER),1,fpDes);
//end

// Calculate palette entries
int  iPaletteEntries = bih.biClrUsed;
if (iPaletteEntries == 0)
iPaletteEntries = 256;

RGBQUAD lpPalette[256] = {0};
// Read palette info
fread(lpPalette, iPaletteEntries, sizeof(RGBQUAD), fpSrc);

//Progress
// 		CProgressDlg dlg;//进度条
// 		dlg.Create();
// 		dlg.SetStep(1);
// 		dlg.SetPos(0);
// 	    dlg.SetWindowText(_T("位图格式转换中..."));
//分批读取数据 200 row
const int oncerow = 200;
const int times = bih.biHeight/oncerow;
for(int i = 0;i<times;i++) //需要处理多少次
{
//dlg.SetPos( (1.0*i/times)*100);
const DWORD dwSize = iPitch * oncerow;
LPBYTE lpData = (LPBYTE)malloc(dwSize*sizeof(BYTE));
fread(lpData, dwSize, sizeof(BYTE), fpSrc);

// Create temporary bitmap
const DWORD dw24Size = _pitch * oncerow;
LPBYTE lp24Data = (LPBYTE)malloc(dw24Size*sizeof(BYTE));

// Convert bitmap
DWORD dwDstHorizontalOffset;
DWORD dwDstVerticalOffset = 0;
DWORD dwDstTotalOffset;

DWORD dwSrcHorizontalOffset;
DWORD dwSrcVerticalOffset = 0;
DWORD dwSrcTotalOffset;

for (long i=0; i<oncerow; i++) //每次转换 200 行
{
dwDstHorizontalOffset = 0;
dwSrcHorizontalOffset = 0;
for (long j=0; j<bih.biWidth; j++)
{
// Update destination total offset
dwDstTotalOffset = dwDstVerticalOffset + dwDstHorizontalOffset;

// Update source total offset
dwSrcTotalOffset = dwSrcVerticalOffset + dwSrcHorizontalOffset;

BYTE red = lpPalette[lpData[dwSrcTotalOffset]].rgbRed;
BYTE green = lpPalette[lpData[dwSrcTotalOffset]].rgbGreen;
BYTE blue = lpPalette[lpData[dwSrcTotalOffset]].rgbBlue;

// Update bitmap
lp24Data[dwDstTotalOffset+2] = red;
lp24Data[dwDstTotalOffset+1] = green;
lp24Data[dwDstTotalOffset] = blue;

// Update destination horizontal offset
dwDstHorizontalOffset += _bpp;

// Update source horizontal offset
dwSrcHorizontalOffset += iBpp;
}

// Update destination vertical offset
dwDstVerticalOffset += _pitch;

// Update source vertical offset
dwSrcVerticalOffset += iPitch;
}
fwrite(lp24Data,sizeof(BYTE),dw24Size,fpDes);
delete[]  lp24Data;
}
//剩余不够 200 行的
const int leftrow  = bih.biHeight%oncerow;
//dlg.SetPos(100);
if(leftrow > 0)
{

const DWORD dwSize = iPitch * leftrow;
LPBYTE lpData = (LPBYTE)malloc(dwSize*sizeof(BYTE));
fread(lpData, dwSize, sizeof(BYTE), fpSrc);

// Create temporary bitmap
const DWORD dw24Size = _pitch * leftrow;
LPBYTE lp24Data = (LPBYTE)malloc(dw24Size*sizeof(BYTE));

// Convert bitmap
DWORD dwDstHorizontalOffset;
DWORD dwDstVerticalOffset = 0;
DWORD dwDstTotalOffset;

DWORD dwSrcHorizontalOffset;
DWORD dwSrcVerticalOffset = 0;
DWORD dwSrcTotalOffset;

for (long i=0; i<leftrow; i++) //每次转换 200 行
{
dwDstHorizontalOffset = 0;
dwSrcHorizontalOffset = 0;
for (long j=0; j<bih.biWidth; j++)
{
// Update destination total offset
dwDstTotalOffset = dwDstVerticalOffset + dwDstHorizontalOffset;

// Update source total offset
dwSrcTotalOffset = dwSrcVerticalOffset + dwSrcHorizontalOffset;

BYTE red = lpPalette[lpData[dwSrcTotalOffset]].rgbRed;
BYTE green = lpPalette[lpData[dwSrcTotalOffset]].rgbGreen;
BYTE blue = lpPalette[lpData[dwSrcTotalOffset]].rgbBlue;

// Update bitmap
lp24Data[dwDstTotalOffset+2] = red;
lp24Data[dwDstTotalOffset+1] = green;
lp24Data[dwDstTotalOffset] = blue;

// Update destination horizontal offset
dwDstHorizontalOffset += _bpp;

// Update source horizontal offset
dwSrcHorizontalOffset += iBpp;
}

// Update destination vertical offset
dwDstVerticalOffset += _pitch;

// Update source vertical offset
dwSrcVerticalOffset += iPitch;
}
fwrite(lp24Data,sizeof(BYTE),dw24Size,fpDes);
delete[]  lp24Data;
}
fclose(fpSrc);
fclose(fpDes);
return TRUE;
}
else
{
fclose(fpSrc);
return FALSE;
}
}