BMP文件读写笔记

一、简介

BMP文件格式，是Windows系统中广泛使用的图像文件格式。由于它可以不作任何变换地保存图像像素域的数据，因此成为我们取得原始数据的重要来源。Windows的图形用户界面（graphical user interfaces）也在它的内建图像子系统GDI中对BMP格式提供了支持。

BMP文件的数据按照从文件头开始的先后顺序分为四个部分：

• bmp文件头(bmp file header)：提供文件的格式、大小等信息
• 位图信息头(bitmap information)：提供图像数据的尺寸、位平面数、压缩方式、颜色索引等信息
• 调色板(color palette)：可选，如使用索引来表示图像，调色板就是索引与其对应的颜色的映射表
•  位图数据(bitmap data)：就是图像数据啦

 

二、文件各个部分详细描述（以字节文单位）：

1、图像文件头

1）1-2：图像文件标识符。0x4d42=’BM’，表示是Windows支持的BMP格式。

2）3-6：整个文件大小。4690 0000，为00009046h=36934。

3）7-8：保留，必须设置为0。

4）9-10：保留，必须设置为0。

5）11-14：从文件开始到位图数据之间的偏移量(14+40+4*（2^biBitCount）)(在有颜色板的情况下)。4600 0000，为00000046h=70，上面的文件头就是35字=70字节。

其结构定义如下: 
typedef   struct   tagBITMAPFILEHEADER 
{ 
WORDbfType;   //   位图文件的类型，必须为BM 
DWORD   bfSize;   //   位图文件的大小，以字节为单位   
WORDbfReserved1;   //   位图文件保留字，必须为0 
WORDbfReserved2;   //   位图文件保留字，必须为0 
DWORD   bfOffBits;   //   位图数据的起始位置，以相对于位图 
//   文件头的偏移量表示，以字节为单位 
}   BITMAPFILEHEADER; 

 

2、位图信息头

6）15-18：位图图信息头长度。

7) 19-22：位图宽度，以像素为单位。8000 0000，为00000080h=128。

8）23-26：位图高度，以像素为单位。9000 0000，为00000090h=144。

9）27-28：位图的位面数，该值总是1。0100，为0001h=1。

10）29-30：每个像素的位数。有1（单色），4（16色），8（256色），16（64K色，高彩色），24（16M色，真彩色），32（4096M色，增强型真彩色）。1000为0010h=16。

11）31-34：压缩说明：有0（不压缩），1（RLE 8，8位RLE压缩），2（RLE 4，4位RLE压缩，3（Bitfields，位域存放）。RLE简单地说是采用像素数+像素值的方式进行压缩（行程编码）。T408采用的是位域存放方式，用两个字节表示一个像素，位域分配为r5b6g5。图中0300 0000为00000003h=3(这张图片不存在颜色板)。

12）35-38：用字节数表示的位图数据的大小，该数必须是4的倍数，数值上等于:一行所占的字节数×位图高度。0090 0000为00009000h=80×90×2h=36864。假设位图是24位,宽为41，高为30，则数值= (biWidth*biBitCount+31)/32*4*biHeight,即=(41*24+31)/32*4*30=3720

13）39-42：用象素/米表示的水平分辨率。A00F 0000为0000 0FA0h=4000。

14）43-46：用象素/米表示的垂直分辨率。A00F 0000为0000 0FA0h=4000。

15）47-50：位图使用的颜色索引数。设为0的话，则说明使用所有调色板项。

16）51-54：对图象显示有重要影响的颜色索引的数目。如果是0，表示都重要。

 

typedef   struct   tagBITMAPINFOHEADER{ 
DWORD   biSize;   //   本结构所占用字节数 
LONGbiWidth;   //   位图的宽度，以像素为单位 
LONGbiHeight;   //   位图的高度，以像素为单位 
WORD   biPlanes;   //   目标设备的级别，必须为1 
WORD   biBitCount//   每个像素所需的位数，必须是1(双色), 
//   4(16色)，8(256色)或24(真彩色)之一 
DWORD   biCompression;   //   位图压缩类型，必须是   0(不压缩), 
//   1(BI_RLE8压缩类型)或2(BI_RLE4压缩类型)之一 
DWORD   biSizeImage;   //   位图的大小，以字节为单位 
LONGbiXPelsPerMeter;   //   位图水平分辨率，每米像素数 
LONGbiYPelsPerMeter;   //   位图垂直分辨率，每米像素数 
DWORD   biClrUsed;//   位图实际使用的颜色表中的颜色数 
DWORD   biClrImportant;//   位图显示过程中重要的颜色数 
}   BITMAPINFOHEADER; 

 

3、彩色板

17）（55+0）到（50-1+2^biBitCount）：彩色板规范。对于调色板中的每个表项，用下述方法来描述RGB的值：

• 1字节用于蓝色分量
• 1字节用于绿色分量
• 1字节用于红色分量
• 1字节用于填充符（设置为0，透明度)

对于24-位真彩色图像就不使用彩色板，因为位图中的RGB值就代表了每个象素的颜色。

如，彩色板为00F8 0000 E007 0000 1F00 0000 0000 0000，其中：

00F8为F800h = 1111 1000 0000 0000（二进制），是蓝色分量的掩码。

E007 为 07E0h = 0000 0111 1110 0000（二进制），是绿色分量的掩码。

1F00为001Fh = 0000 0000 0001  1111（二进制），是红色分量的掩码。

0000 总设置为0。

将掩码跟像素值进行“与”运算再进行移位操作就可以得到各色分量值。看看掩码，就可以明白事实上在每个像素值的两个字节16位中，按从高到低取5、6、5位分别就是r、g、b分量值。取出分量值后把r、g、b值分别乘以8、4、8就可以补齐第个分量为一个字节，再把这三个字节按rgb组合，放入存储器（同样要反序），就可以转换为24位标准BMP格式了。

颜色表结构的定义如下: 

typedef   struct   tagRGBQUAD   { 
BYTErgbBlue;//   蓝色的亮度(值范围为0-255) 
BYTErgbGreen;   //   绿色的亮度(值范围为0-255) 
BYTErgbRed;   //   红色的亮度(值范围为0-255) 
BYTErgbReserved;//   保留，必须为0 
}   RGBQUAD; 
颜色表中结构数据的个数有biBitCount来确定: 
当biBitCount=1,4,8时，分别有2,16,256个表项; 
当biBitCount=24时，没有颜色表项。 
位图信息头和颜色表组成位图信息，BITMAPINFO结构定义如下: 
typedef   struct   tagBITMAPINFO   { 
BITMAPINFOHEADER   bmiHeader;   //   位图信息头 
RGBQUAD   bmiColors[1];   //   颜色表 
}   BITMAPINFO; 

 

4、图像数据阵列

位图数据记录了位图的每一个像素值，记录顺序是在扫描行内是从左到右,扫描行之间是从下到上。位图的一个像素值所占的字节数: 
当biBitCount=1时，8个像素占1个字节; 
当biBitCount=4时，2个像素占1个字节; 
当biBitCount=8时，1个像素占1个字节; 
当biBitCount=24时,1个像素占3个字节; 
Windows规定一个扫描行所占的字节数必须是 
4的倍数(即以long为单位),不足的以0填充， 
一个扫描行所占的字节数计算方法: 
DataSizePerLine=   (biWidth*   biBitCount+31)/8;   
//   一个扫描行所占的字节数 
DataSizePerLine=   DataSizePerLine/4*4;   //   字节数必须是4的倍数 
 

三、通过C语言结构体定义说明BMP主要的四个部分

1、bmp文件头

typedef struct
{
    unsigned short    bfType; //文件类型：0x4D42（十六进制ASCII码'BM'
    unsigned long    bfSize;//文件大小，字节单位表示
    unsigned short    bfReserved1;//保留，必须设0
    unsigned short    bfReserved2;//保留，必须设0
    unsigned long    bfOffBits;//说明从文件头到实际图像数据之间的偏移量
} ClBitMapFileHeader;

2、位图信息头

typedef struct
{
    unsigned long  biSize;//说明位图信息头结构所需要的字节数
    long   biWidth;//列出，像素为单位
    long   biHeight;//行数，像素为单位
    unsigned short   biPlanes;//为目标设备说明位面数，其值将总是被设为1
    unsigned short   biBitCount;//说明比特数/象素，其值为1、4、8、16、24、或32,平时用到的图像绝大部分是24位(真彩色)和8位256色
    unsigned long  biCompression;//说明图象数据压缩的类型，一般没有没有压缩的类型，所以没有此项数据    
    unsigned long  biSizeImage;//说明图象的大小，以字节为单位
    long   biXPelsPerMeter;//说明水平分辨率，用象素/米表示
    long   biYPelsPerMeter;//说明垂直分辨率，用象素/米表示
    unsigned long   biClrUsed;//说明位图实际使用的彩色表中的颜色索引数（设为0的话，则说明使用所有调色板项）。
    unsigned long   biClrImportant;//说明对图象显示有重要影响的颜色索引的数目，如果是0，表示都重要
14 } ClBitMapInfoHeader;

3、调色板

typedef struct
{
    unsigned char rgbBlue; //该颜色的蓝色分量  
    unsigned char rgbGreen; //该颜色的绿色分量  
    unsigned char rgbRed; //该颜色的红色分量  
    unsigned char rgbReserved; //保留值  
} ClRgbQuad;

 

4、位图数据

在文件头、位图信息头和调色板（如果有的话）之后，就是位图数据阵列了，

typedef struct
{
    int width;  //宽度，像素单位
    int height;//高度,像素单位
    int channels;//通道数
    unsigned char* imageData;//图像数据
}ClImage;

四、读取BMP文件

位图的一个像素值所占的字节数不同时，每个像素的存储大小不同，读取位图图像数据时需要对不同的位图采用不同的处理，8位和24位为常用的两种类型，这里首先介绍，1位的二值图一个字节表示8个像素信息，需要通过位运算解析出每个像素的值（0或1），通过在对8位位图读取方法进行扩充实现。

1）8bit位图读取

if (bmpInfoHeader.biBitCount == 8)//256色位图
        {
            channels = 1;
            //每行数据量是4字节整数倍
            offset = (channels*width) % 4;
            //计算每行需要在有效数据后填充的无意义字节数
            if (offset != 0)
            {
                offset = 4 - offset;
            }
            bmpImg->channels = 1;
            bmpImg->imageData = (unsigned char*)malloc(sizeof(unsigned char)*width*height);
            step = channels*width; //每行宽度（字节为单位）
            quad = (ClRgbQuad*)malloc(sizeof(ClRgbQuad) * 256); 
            //读取调色板，8位字符调色板包含256种颜色
            fread(quad, sizeof(ClRgbQuad), 256, pFile);
            free(quad);
            //读每个像素的值
            for (i = 0; i < height; i++)
            {
                for (j = 0; j < width; j++)
                {
                    fread(&pixVal, sizeof(unsigned char), 1, pFile);
                    // 坐标原点在左下角=》(height - 1 - i)*step+j，通过这个变换坐标原点变为左上角
                    bmpImg->imageData[(height - 1 - i)*step + j] = pixVal;
                }
               //读行末尾无意义的字节
                if (offset != 0)
                {
                    for (j = 0; j < offset; j++)
                    {
                        fread(&pixVal, sizeof(unsigned char), 1, pFile);  //读取每行的空字节
                    }
                }
            }
        }

2）24bit位图读取

 if (bmpInfoHeader.biBitCount == 24)
        {
            //3通道， 每个像元占3列
            channels = 3;
            bmpImg->channels = 3; 
             //每个像元占3列,数据块是8位的3倍
            bmpImg->imageData = (unsigned char*)malloc(sizeof(unsigned char)*width * 3 * height);
            step = channels*width;//每行宽度，字节为单位（只包括有效数据）
             //计算空白数据，因为每行的长度只能是4的整数倍，如果不是，则以空白补上
            offset = (channels*width) % 4;
            if (offset != 0)
            {
                offset = 4 - offset;
            }
            for (i = 0; i < height; i++)
            {
                for (j = 0; j < width; j++)
                {
                    for (k = 0; k < 3; k++) //三个通道分别读取
                    {
                        fread(&pixVal, sizeof(unsigned char), 1, pFile);
                        bmpImg->imageData[(height - 1 - i)*step + j * 3 + k] = pixVal;
                    }
                }
                if (offset != 0)
                {
                    for (j = 0; j < offset; j++)
                    {
                        fread(&pixVal, sizeof(unsigned char), 1, pFile); //读空白
                    }
                }
            }
        }

3）1bit位图（黑白图、二值图）

    if (bmpInfoHeader.biBitCount == 1) {//二值图
            channels = 1;
            //一个字节存8个像素，除以8向上取整得到字节数
            offset = ((int)ceil(width / 8.0)) % 4; 
            //求每行末尾的无意义字节数
            if (offset != 0)
            {
                offset = 4 - offset;
            }
            bmpImg->channels = 1;
            //存数据的数据块，每个像素用一个字节
            bmpImg->imageData = (unsigned char*)malloc(sizeof(unsigned char)*width*height);
            step = channels*width; //每行宽度，字节为单位
             //读取调色板，二值图像调色板只有两种颜色
             quad = (ClRgbQuad*)malloc(sizeof(ClRgbQuad) * 2); 
            fread(quad, sizeof(ClRgbQuad), 2, pFile);
            free(quad);
            int w = (int)ceil(width / 8.0);//每行占的字节数
            //用于临时存储从每个字节读取出来的像素值
            unsigned char bits[8];
            //计数器，每行达到图像宽度（width-1），说明后面的bit均为无效，因为最后一个有效字节也只有部分bits是有效的
            int m = 0;
            for (i = 0; i < height; i++)
            {
                m = 0;
                for (j = 0; j < w; j++)
                {
                    fread(&pixVal, sizeof(unsigned char), 1, pFile);
                    //获取字符中没一位的值，以一个unsigned char[8]的数组存储
                    get_bitsofchar(bits, pixVal);
                    //把每个字节的8位值解析出来，分别存入8个字节
                    for (int k = 0; k < 8; k++) {
                        if (m < width) {
                            //    count[(height - 1 - i)*step + m] = bits[k];
                            if (bits[k] == 1) { //把值1映射为8位图中的255
                                bits[k] = 255;
                            }
                            // 坐标原点在左下角=》(height - 1 - i)*step+j，通过这个变换坐标原点变为左上角
                            bmpImg->imageData[(height - 1 - i)*step + m] = bits[k];
                        }
                        m++;
                    }
                }
                if (offset != 0)
                {
                    for (j = 0; j < offset; j++)
                    {
                        fread(&pixVal, sizeof(unsigned char), 1, pFile);  //读取每行的空字节
                    }
                }
            }
            for (int i = 0; i < height; i++) {
                for (int j = 0; j < width; j++) {
                    printf("%d ", bmpImg->imageData[i*width + j]);
                }
                printf("\n");
            }
        }

代码中，为了从字节的8位中解析出8个像素值，定义了位运算函数如下：

//获取一个字节中pos位的值（0或1)
unsigned char  read_bit(char c, int   pos)
{
    char   b_mask = 0x01;
    b_mask = b_mask << pos;
    //字符c和b_mask做位运算如果还是等于b_mask,说明该位为1 
    if ((c&b_mask) == b_mask)
        return   1;
    else
        return   0;
}

//将一个Char的所有bit以单个数值（0、1）的形式解析出来
void  get_bitsofchar(unsigned char bits[8], char c)
{
    int k = 0;
    unsigned char t;
    for (k = 0; k < 8; k++)
    {
        bits[k] = read_bit(c, k);
    }
    //逆序排列各个bit位——计算机中顺序是从低位向高位排列的
    for (k = 0; k < 4; k++)
    {
        t = bits[k];
        bits[k] = bits[7 - k];
        bits[7 - k] = t;
    }
}

六、写BMP文件

1、写8bit位图

    //先写文件类型标识
         fileType = 0x4D42;
    fwrite(&fileType, sizeof(unsigned short), 1, pFile);
     if (bmpImg->channels == 1)//8位，单通道，灰度图  
    {      
                //每行字节数
        step = bmpImg->width;
               //如果step 不是4字节的整数倍，凑整
        offset = step % 4;
        if (offset != 0)
        {
            offset = 4 - offset;
            step += offset;
        }
                //写文件头
        bmpFileHeader.bfSize = 54 + 256 * 4 + bmpImg->width;
        bmpFileHeader.bfReserved1 = 0;
        bmpFileHeader.bfReserved2 = 0;
        bmpFileHeader.bfOffBits = 54 + 256 * 4;
        fwrite(&bmpFileHeader, sizeof(ClBitMapFileHeader), 1, pFile);
                 //写位图信息头
        bmpInfoHeader.biSize = 40;
        bmpInfoHeader.biWidth = bmpImg->width;
        bmpInfoHeader.biHeight = bmpImg->height;
        bmpInfoHeader.biPlanes = 1;
        bmpInfoHeader.biBitCount = 8;
        bmpInfoHeader.biCompression = 0;
        bmpInfoHeader.biSizeImage = bmpImg->height*step;
        bmpInfoHeader.biXPelsPerMeter = 0;
        bmpInfoHeader.biYPelsPerMeter = 0;
        bmpInfoHeader.biClrUsed = 256;
        bmpInfoHeader.biClrImportant = 256;
        fwrite(&bmpInfoHeader, sizeof(ClBitMapInfoHeader), 1, pFile);
        //写调色板，是一个灰度值序列，长度255
        quad = (ClRgbQuad*)malloc(sizeof(ClRgbQuad) * 256);
        for (i = 0; i < 256; i++)
        {
            quad[i].rgbBlue = i;
            quad[i].rgbGreen = i;
            quad[i].rgbRed = i;
            quad[i].rgbReserved = 0;
        }
        fwrite(quad, sizeof(ClRgbQuad), 256, pFile);
        free(quad);
               //写每个像素
        for (i = bmpImg->height - 1; i > -1; i--)
        {
            for (j = 0; j < bmpImg->width; j++)
            {
                pixVal = bmpImg->imageData[i*bmpImg->width + j];
                fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
            }
                        //写无意义充填字节
            if (offset != 0)
            {
                for (j = 0; j < offset; j++)
                {
                    pixVal = 0;
                    fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
                }
            }
        }
    }

2、写24bit位图

      fileType = 0x4D42;
    fwrite(&fileType, sizeof(unsigned short), 1, pFile);
          //24位，3通道，真彩图  
    if (bmpImg->channels == 3)
    {
        step = bmpImg->channels*bmpImg->width;
        offset = step % 4;
        if (offset != 0)
        {
            offset = 4 - offset;
            step += offset;
        }
                //写文件头
        bmpFileHeader.bfSize = bmpImg->height*step + 54;
        bmpFileHeader.bfReserved1 = 0;
        bmpFileHeader.bfReserved2 = 0;
        bmpFileHeader.bfOffBits = 54;
        fwrite(&bmpFileHeader, sizeof(ClBitMapFileHeader), 1, pFile);
                //写位图信息头
        bmpInfoHeader.biSize = 40;
        bmpInfoHeader.biWidth = bmpImg->width;
        bmpInfoHeader.biHeight = bmpImg->height;
        bmpInfoHeader.biPlanes = 1;
        bmpInfoHeader.biBitCount = 24;
        bmpInfoHeader.biCompression = 0;
        bmpInfoHeader.biSizeImage = bmpImg->height*step;
        bmpInfoHeader.biXPelsPerMeter = 0;
        bmpInfoHeader.biYPelsPerMeter = 0;
        bmpInfoHeader.biClrUsed = 0;
        bmpInfoHeader.biClrImportant = 0;
        fwrite(&bmpInfoHeader, sizeof(ClBitMapInfoHeader), 1, pFile);
               //写像素每个像素有3个值（R,G,B）
        for (i = bmpImg->height - 1; i > -1; i--)
        {
            for (j = 0; j < bmpImg->width; j++)
            {
                pixVal = bmpImg->imageData[i*bmpImg->width * 3 + j * 3];
                fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
                pixVal = bmpImg->imageData[i*bmpImg->width * 3 + j * 3 + 1];
                fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
                pixVal = bmpImg->imageDat，a[i*bmpImg->width * 3 + j * 3 + 2];
                fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
            }
            if (offset != 0)
            {
                for (j = 0; j < offset; j++)
                {
                    pixVal = 0;
                    fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
                }
            }
        }
    }

 

参考资料：

【1】百度百科：BMP文件

【2】CSDN博客：用C语言对BMP进行读写

【3】CSDN博客：BMP格式介绍

【4】博客园：C语言编写BMP读写程序

源代码：

bmp.h文件：

#pragma once
#include <stdio.h>  
typedef struct
{
  //  unsigned short    bfType;  //不单独读就出错 （2bytes）
    unsigned long    bfSize; //文件大小，字节单位表示（4bytes）
    unsigned short    bfReserved1;//保留，必须设0（2bytes）
    unsigned short    bfReserved2;//保留，必须设0（2bytes）
    unsigned long    bfOffBits;//说明从文件头到实际图像数据之间的偏移量（4bytes）
} ClBitMapFileHeader;

//C语言结构体大小计算规则：
//1、每个成员的偏移量都必须是当前成员所占内存大小的整数倍如果不是编译器会在成员之间加上填充字节。
//2、当所有成员大小计算完毕后，编译器判断当前结构体大小是否是结构体中最宽的成员变量大小的整数倍
//如果不是会在最后一个成员后做字节填充。

typedef struct
{
    unsigned long  biSize;//说明位图信息头结构所需要的字节数（4bytes）
    long   biWidth;//列出，像素为单位（4bytes）
    long   biHeight;//行数，像素为单位（4bytes）
    unsigned short   biPlanes;//为目标设备说明位面数，其值将总是被设为1（2bytes）
    unsigned short   biBitCount;//说明比特数/象素，其值为1、4、8、16、24、或32,平时用到的图像绝大部分是24位(真彩色)和8位256色（2bytes）
    unsigned long  biCompression;//说明图象数据压缩的类型，一般没有没有压缩的类型，一般为0  （4bytes） 
    unsigned long  biSizeImage;//说明图象的大小，以字节为单位（4bytes） 
    long   biXPelsPerMeter; //说明水平分辨率，用象素/米表示（4bytes） 
    long   biYPelsPerMeter;//说明垂直分辨率，用象素/米表示（4bytes） 
    unsigned long   biClrUsed;//说明位图实际使用的彩色表中的颜色索引数（设为0的话，则说明使用所有调色板项）。（4bytes） 
    unsigned long   biClrImportant;//说明对图象显示有重要影响的颜色索引的数目，如果是0，表示都重要（4bytes） 
} ClBitMapInfoHeader;

typedef struct
{
    unsigned char rgbBlue; //该颜色的蓝色分量  
    unsigned char rgbGreen; //该颜色的绿色分量  
    unsigned char rgbRed; //该颜色的红色分量  
    unsigned char rgbReserved; //保留值  
} ClRgbQuad;

typedef struct
{
    int width;  //宽度，像素单位
    int height;//高度,像素单位
    int channels;//通道数
    unsigned char* imageData;//图像数据
}ClImage;

//读取文件
ClImage* clLoadImage(char* path); 
//保存文件
bool clSaveImage(char* path, ClImage* bmpImg);

 

注：根据C语言中结构体大小的计算规则（参考：C语言结构体大小计算），结构体变量的Size并不一定是其所有字段size之和，导致如果直接用一个结构体变量作为读入数据块的容器，可能产生偏差。因此，对文件头的结构体定义去掉了字段bfType，而是在读文件的程序中单独用一个变量读取该信息。

bmp.cpp文件：

#include "bmp.h"  
#include <stdio.h>  
#include <stdlib.h>  
#include <math.h>

//获取一个字节中pos位的值（0或1)
unsigned char  read_bit(char c, int   pos)
{
    char   b_mask = 0x01;
    b_mask = b_mask << pos;
    //字符c和b_mask做位运算如果还是等于b_mask,说明该位为1 
    if ((c&b_mask) == b_mask)
        return   1;
    else
        return   0;
}

//将一个Char的所有bit以单个数值（0、1）的形式解析出来
void  get_bitsofchar(unsigned char bits[8], char c)
{
    int k = 0;
    unsigned char t;
    for (k = 0; k < 8; k++)
    {
        bits[k] = read_bit(c, k);
    }
    //逆序排列各个bit位——计算机中顺序是从低位向高位排列的
    for (k = 0; k < 4; k++)
    {
        t = bits[k];
        bits[k] = bits[7 - k];
        bits[7 - k] = t;
    }
}
/*
读取BMP文件，返回一个ClImage对象
*/
ClImage* clLoadImage(char* path)
{
    ClImage* bmpImg;
    FILE* pFile;
    unsigned short fileType;
    ClBitMapFileHeader bmpFileHeader;
    ClBitMapInfoHeader bmpInfoHeader;
    int channels = 1;
    int width = 0;
    int height = 0;
    int step = 0;
    int offset = 0;
    unsigned char pixVal;
    ClRgbQuad* quad;
    int i, j, k;

    bmpImg = (ClImage*)malloc(sizeof(ClImage));
    //pFile = fopen(path, "rb");
    fopen_s(&pFile, path, "rb");
    if (!pFile)
    {
        free(bmpImg);
        return NULL;
    }
    //如果不先读取bifType，根据C语言结构体Sizeof运算规则——整体大于部分之和，从而导致读文件错位
    fread(&fileType, sizeof(unsigned short), 1, pFile);
    if (fileType == 0x4D42)
    {
        printf("文件类型标识正确! \n");
        //读文件头（12bytes，除去bifType）
        fread(&bmpFileHeader, sizeof(ClBitMapFileHeader), 1, pFile);
        printf("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n");
        printf("bmp文件头信息：\n");
        printf("文件大小：%d \n", bmpFileHeader.bfSize);
        printf("保留字：%d \n", bmpFileHeader.bfReserved1);
        printf("保留字：%d \n", bmpFileHeader.bfReserved2);
        printf("位图数据偏移字节数：%d \n", bmpFileHeader.bfOffBits);
        //读位图信息头40bytes
        fread(&bmpInfoHeader, sizeof(ClBitMapInfoHeader), 1, pFile);
        printf("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n");
        printf("bmp文件信息头\n");
        printf("结构体长度：%d \n", bmpInfoHeader.biSize);
        printf("位图宽度：%d \n", bmpInfoHeader.biWidth);
        printf("位图高度：%d \n", bmpInfoHeader.biHeight);
        printf("位图平面数：%d \n", bmpInfoHeader.biPlanes);
        printf("颜色位数：%d \n", bmpInfoHeader.biBitCount);
        printf("压缩方式：%d \n", bmpInfoHeader.biCompression);
        printf("实际位图数据占用的字节数：%d \n", bmpInfoHeader.biSizeImage);
        printf("X方向分辨率：%d \n", bmpInfoHeader.biXPelsPerMeter);
        printf("Y方向分辨率：%d \n", bmpInfoHeader.biYPelsPerMeter);
        printf("使用的颜色数：%d \n", bmpInfoHeader.biClrUsed);
        printf("重要颜色数：%d \n", bmpInfoHeader.biClrImportant);
        printf("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\n");

        //获取图像宽度，高度
        width = bmpInfoHeader.biWidth;
        height = bmpInfoHeader.biHeight;
        bmpImg->width = width;
        bmpImg->height = height;

        if (bmpInfoHeader.biBitCount == 1) {//二值图
            printf("该文件有调色板，即该位图二值图\n\n");
            channels = 1;
            offset = ((int)ceil(width / 8.0)) % 4;  //一个字节存8个像素

            //求每行末尾的空字节数
            if (offset != 0)
            {
                offset = 4 - offset;
            }
            bmpImg->channels = 1;
            bmpImg->imageData = (unsigned char*)malloc(sizeof(unsigned char)*width*height);
            step = channels*width; //每行宽度

            quad = (ClRgbQuad*)malloc(sizeof(ClRgbQuad) * 2); //读取调色板
            fread(quad, sizeof(ClRgbQuad), 2, pFile);
            free(quad);


            int w = (int)ceil(width / 8.0);//每行占的字节数
            unsigned char bits[8];
            int m = 0;
            for (i = 0; i < height; i++)
            {
                m = 0;
                for (j = 0; j < w; j++)
                {
                    fread(&pixVal, sizeof(unsigned char), 1, pFile);
                    //获取字符中没一位的值，以一个unsigned char[8]的数组存储
                    get_bitsofchar(bits, pixVal);
                    //把每个字节的8位值解析出来，分别存入8个字节
                    for (int k = 0; k < 8; k++) {
                        if (m < width) {
                            //    count[(height - 1 - i)*step + m] = bits[k];
                            if (bits[k] == 1) { //把值1映射为8位图中的255
                                bits[k] = 255;
                            }
                            // 坐标原点在左下角=》(height - 1 - i)*step+j，通过这个变换坐标原点变为左上角
                            bmpImg->imageData[(height - 1 - i)*step + m] = bits[k];
                        }
                        m++;
                    }
                }
                if (offset != 0)
                {
                    for (j = 0; j < offset; j++)
                    {
                        fread(&pixVal, sizeof(unsigned char), 1, pFile);  //读取每行的空字节
                    }
                }
            }
            for (int i = 0; i < height; i++) {
                for (int j = 0; j < width; j++) {
                    printf("%d ", bmpImg->imageData[i*width + j]);
                }
                printf("\n");
            }
        }


        else if (bmpInfoHeader.biBitCount == 4) {//十六色位图
            //一般不用这种格式
        }
        else if (bmpInfoHeader.biBitCount == 8)//256色位图
        {
            printf("该文件有调色板，即该位图为非真彩色8位256色位图\n\n");
            channels = 1;
            offset = (channels*width) % 4;
            if (offset != 0)
            {
                offset = 4 - offset;
            }
            bmpImg->channels = 1;
            bmpImg->imageData = (unsigned char*)malloc(sizeof(unsigned char)*width*height);
            step = channels*width; //每行宽度

            quad = (ClRgbQuad*)malloc(sizeof(ClRgbQuad) * 256); //读取调色板
            fread(quad, sizeof(ClRgbQuad), 256, pFile);
            free(quad);

            for (i = 0; i < height; i++)
            {
                for (j = 0; j < width; j++)
                {
                    fread(&pixVal, sizeof(unsigned char), 1, pFile);
                    // 坐标原点在左下角=》(height - 1 - i)*step+j，通过这个变换坐标原点变为左上角
                    bmpImg->imageData[(height - 1 - i)*step + j] = pixVal;
                }
                if (offset != 0)
                {
                    for (j = 0; j < offset; j++)
                    {
                        fread(&pixVal, sizeof(unsigned char), 1, pFile);  //读取每行的空字节
                    }
                }
            }
        }
        //16位高彩色图
        else if (bmpInfoHeader.biBitCount == 16) {
            //一般不用这种格式
        }
        //真彩色
        else if (bmpInfoHeader.biBitCount == 24)
        {
            printf("该位图为位真彩色\n\n");
            channels = 3;
            bmpImg->channels = 3;  //每个像元占3列
            bmpImg->imageData = (unsigned char*)malloc(sizeof(unsigned char)*width * 3 * height);
            step = channels*width;
            offset = (channels*width) % 4;
            if (offset != 0)
            {
                offset = 4 - offset; //计算空白数据，因为每行的长度只能是4的整数倍，如果不是，则以空白补上
            }

            for (i = 0; i < height; i++)
            {
                for (j = 0; j < width; j++)
                {
                    for (k = 0; k < 3; k++) //三个通道分别读取
                    {
                        fread(&pixVal, sizeof(unsigned char), 1, pFile);
                        bmpImg->imageData[(height - 1 - i)*step + j * 3 + k] = pixVal;
                    }
                    //kzSetMat(bmpImg->mat, height-1-i, j, kzScalar(pixVal[0], pixVal[1], pixVal[2]));  
                }
                if (offset != 0)
                {
                    for (j = 0; j < offset; j++)
                    {
                        fread(&pixVal, sizeof(unsigned char), 1, pFile); //读空白
                    }
                }
            }
        }
        else if (bmpInfoHeader.biBitCount == 32) { //32位位图--具有透明透明通道
            //一般不用这种格式
        }
    }
    return bmpImg;
}

bool clSaveImage(char* path, ClImage* bmpImg)
{
    FILE *pFile;
    unsigned short fileType;
    ClBitMapFileHeader bmpFileHeader;
    ClBitMapInfoHeader bmpInfoHeader;
    int step;
    int offset;
    unsigned char pixVal = '\0';
    int i, j;
    ClRgbQuad* quad;

    //pFile = fopen(path, "wb");
    fopen_s(&pFile, path, "wb");
    if (!pFile)
    {
        return false;
    }
//
       fileType = 0x4D42;
    fwrite(&fileType, sizeof(unsigned short), 1, pFile);


    if (bmpImg->channels == 3)//24位，通道，彩图  
    {
        step = bmpImg->channels*bmpImg->width;
        offset = step % 4;
        if (offset != 0)
        {
            offset = 4 - offset;
            step += offset;
        }
        /*一个BUG
        if (offset != 4) {
            step += 4 - offset;
        }*/
        //bmpFileHeader.bfType = 0x4D42;
        bmpFileHeader.bfSize = bmpImg->height*step + 54;
        bmpFileHeader.bfReserved1 = 0;
        bmpFileHeader.bfReserved2 = 0;
        bmpFileHeader.bfOffBits = 54;
        fwrite(&bmpFileHeader, sizeof(ClBitMapFileHeader), 1, pFile);

        bmpInfoHeader.biSize = 40;
        bmpInfoHeader.biWidth = bmpImg->width;
        bmpInfoHeader.biHeight = bmpImg->height;
        bmpInfoHeader.biPlanes = 1;
        bmpInfoHeader.biBitCount = 24;
        bmpInfoHeader.biCompression = 0;
        bmpInfoHeader.biSizeImage = bmpImg->height*step;
        bmpInfoHeader.biXPelsPerMeter = 0;
        bmpInfoHeader.biYPelsPerMeter = 0;
        bmpInfoHeader.biClrUsed = 0;
        bmpInfoHeader.biClrImportant = 0;
        fwrite(&bmpInfoHeader, sizeof(ClBitMapInfoHeader), 1, pFile);

        for (i = bmpImg->height - 1; i > -1; i--)
        {
            for (j = 0; j < bmpImg->width; j++)
            {
                pixVal = bmpImg->imageData[i*bmpImg->width * 3 + j * 3];
                fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
                pixVal = bmpImg->imageData[i*bmpImg->width * 3 + j * 3 + 1];
                fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
                pixVal = bmpImg->imageData[i*bmpImg->width * 3 + j * 3 + 2];
                fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
            }
            if (offset != 0)
            {
                for (j = 0; j < offset; j++)
                {
                    pixVal = 0;
                    fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
                }
            }
        }
    }

    else if (bmpImg->channels == 1)//8位，单通道，灰度图  
    {
        step = bmpImg->width;
        offset = step % 4;
        if (offset != 0)
        {
            offset = 4 - offset;
            step += offset;
        }
        //bmpFileHeader.bfType = 0x4D42;
        bmpFileHeader.bfSize = 54 + 256 * 4 + bmpImg->width;
        bmpFileHeader.bfReserved1 = 0;
        bmpFileHeader.bfReserved2 = 0;
        bmpFileHeader.bfOffBits = 54 + 256 * 4;
        fwrite(&bmpFileHeader, sizeof(ClBitMapFileHeader), 1, pFile);

        bmpInfoHeader.biSize = 40;
        bmpInfoHeader.biWidth = bmpImg->width;
        bmpInfoHeader.biHeight = bmpImg->height;
        bmpInfoHeader.biPlanes = 1;
        bmpInfoHeader.biBitCount = 8;
        bmpInfoHeader.biCompression = 0;
        bmpInfoHeader.biSizeImage = bmpImg->height*step;
        bmpInfoHeader.biXPelsPerMeter = 0;
        bmpInfoHeader.biYPelsPerMeter = 0;
        bmpInfoHeader.biClrUsed = 256;
        bmpInfoHeader.biClrImportant = 256;
        fwrite(&bmpInfoHeader, sizeof(ClBitMapInfoHeader), 1, pFile);

        //调色板是一个灰度图
        quad = (ClRgbQuad*)malloc(sizeof(ClRgbQuad) * 256);
        for (i = 0; i < 256; i++)
        {
            quad[i].rgbBlue = i;
            quad[i].rgbGreen = i;
            quad[i].rgbRed = i;
            quad[i].rgbReserved = 0;
        }
        fwrite(quad, sizeof(ClRgbQuad), 256, pFile);
        free(quad);

        for (i = bmpImg->height - 1; i > -1; i--)
        {
            for (j = 0; j < bmpImg->width; j++)
            {
                pixVal = bmpImg->imageData[i*bmpImg->width + j];
                fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
            }
            if (offset != 0)
            {
                for (j = 0; j < offset; j++)
                {
                    pixVal = 0;
                    fwrite(&pixVal, sizeof(unsigned char), 1, pFile);
                }
            }
        }
    }
    fclose(pFile);

    return true;
}

 

主程序文件：

#include "bmp.h"  
#include <stdio.h>

void main()
{
    ClImage* img = clLoadImage("c:/122.bmp");
    bool flag = clSaveImage("c:/result.bmp", img);
    if (flag)
    {
        printf("save ok... \n");
    }
}