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");
    }
}