BMP RGB888转RGB565 +上下翻转+缩放

 

典型的BMP图像文件由四部分组成：

(1) 位图头文件数据结构，它包含BMP图像文件的类型、文件大小和位图起始位置等信息；

　　

typedef struct tagBITMAPFILEHEADER {

        WORD    bfType;//位图文件的类型，必须为BM(1-2字节）

        DWORD   bfSize;//位图文件的大小，以字节为单位（3-6字节，低位在前）

        WORD    bfReserved1;//位图文件保留字，必须为0(7-8字节）

        WORD    bfReserved2;//位图文件保留字，必须为0(9-10字节）

        DWORD   bfOffBits;//位图数据的起始位置，以相对于位图（11-14字节，低位在前）

} BITMAPFILEHEADER;

(2) 位图信息数据结构，它包含有BMP图像的宽、高、压缩方法，以及定义颜色等信息；

typedef struct tagBITMAPINFOHEADER{

        DWORD      biSize;//本结构所占用字节数（15-18字节）

        LONG       biWidth;//位图的宽度，以像素为单位（19-22字节）

        LONG       biHeight;//位图的高度，以像素为单位（23-26字节）

        WORD       biPlanes;

        WORD       biBitCount;//每个像素所需的位数，必须是1（双色），（29-30字节） //4(16色），8(256色）16(高彩色)或24（真彩色）之一 

        DWORD      biCompression;

        DWORD      biSizeImage;//位图的大小(其中包含了为了补齐行数是4的倍数而添加的空字节)，以字节为单位（35-38字节）

        LONG       biXPelsPerMeter;

        LONG       biYPelsPerMeter;

        DWORD      biClrUsed;

        DWORD      biClrImportant;

} BITMAPINFOHEADER;

(3) 调色板，这个部分是可选的，有些位图需要调色板，有些位图，比如真彩色图（24位的BMP）就不需要调色板；

(4) 位图数据，这部分的内容根据BMP位图使用的位数不同而不同，在24位图中直接使用RGB，而其他的小于24位的使用调色板中颜色索引值。

 

1. 打开位图并显示

    BITMAPFILEHEADER bmpHeader;//文件头

    BITMAPINFOHEADER bmpInfo;//信息头



    CFileDialog dlg(TRUE, "*.BMP", NULL, NULL,"位图文件(*.BMP)|*.bmp;*.BMP|",this);

    CFile bmpFile;//记录打开文件

    CString strFileName;//记录选择文件路径

    if (!dlg.DoModal() == IDOK) return;

    strFileName = dlg.GetPathName();



    //以只读的方式打开文件

    if(!bmpFile.Open(strFileName, CFile::modeRead|CFile::typeBinary)) return;



    //读取文件头到bmpHeader

    if (bmpFile.Read(&bmpHeader,sizeof(BITMAPFILEHEADER)) != sizeof(BITMAPFILEHEADER))

    {

        AfxMessageBox("read bmp header failed!");

        return;

    }



    /*0x4d42=’BM’，表示是Windows支持的BMP格式。

    (注意：查ascii表B 0x42,M0x4d,bfType 为两个字节，B为low字节，M为high字节

    所以bfType=0x4D42，而不是0x424D

    */

    if (bmpHeader.bfType != 0x4d42)

    {

        AfxMessageBox("invalid file type!");

        return;

    }



    //读取文件信息头bmpInfo

    if (bmpFile.Read(&bmpInfo,sizeof(BITMAPINFOHEADER)) != sizeof(BITMAPINFOHEADER))

    {

        AfxMessageBox("read bmp infor header failed!");

        return;

    }

    //确认是24位位图

    if (bmpInfo.biBitCount != 24)//图像的位数

    {

        AfxMessageBox("File is not 24 bit.Application doesn't support this kind of file!");

        return;

    }

    /*

        typedef struct tagBITMAPINFO {

            BITMAPINFOHEADER    bmiHeader;

            RGBQUAD             bmiColors[1];

        } BITMAPINFO;

    */

    pBmpInfo = (BITMAPINFO *)new char[sizeof(BITMAPINFOHEADER)];

    if (!pBmpInfo)

    {

        AfxMessageBox("memory error!");

        return;

    }

    //为图像数据申请空间

    memcpy(pBmpInfo, &bmpInfo, sizeof(BITMAPINFOHEADER));

    //计算颜色表区域大小：结构体的大小(包含颜色表)-颜色数据的偏移量

    DWORD dataBytes = bmpHeader.bfSize - bmpHeader.bfOffBits;

    pBmpData = (BYTE*)new char[dataBytes];

    if (!pBmpData)

    {

        AfxMessageBox("memory error!");

        delete pBmpData;

        return;

    }

    if (bmpFile.Read(pBmpData,dataBytes) != dataBytes)

    {

        AfxMessageBox("Read bmp data failed!");

        delete pBmpInfo;

        delete pBmpData;

        return;

    }

    //bmpFile.Close();



    CWnd *pWnd=GetDlgItem(IDC_IMAGE);//获得pictrue控件窗口的句柄

    CRect rect;

    pWnd->GetClientRect(&rect);//获得pictrue控件所在的矩形区域

    CDC *pDC=pWnd->GetDC();//获得pictrue控件的DC

    //显示图片

    pDC->SetStretchBltMode(COLORONCOLOR);



    StretchDIBits(pDC->GetSafeHdc(),0,0,rect.Width(),rect.Height(),0,0,bmpInfo.biWidth,bmpInfo.biHeight,pBmpData,pBmpInfo,DIB_RGB_COLORS,SRCCOPY);



    iBmpWidth = bmpInfo.biWidth;                     

    iBmpHeight = bmpInfo.biHeight;

 

2. 将24位图转化为16位位图（从RGB888到RGB565）

需要将原来的颜色表数据分离成R，G，B三组，然后R舍弃3位，G舍弃2位，B舍弃3位。

a. 分离，读取RGB数据存到三个BYTE*数组里m_pR, m_pG, m_pB;

　　　　 LARGE_INTEGER liSize;

        liSize.QuadPart = 0;

        ::GetFileSizeEx(bmpFile, &liSize);



        int nBitmapSize = abs(iBmpHeight) * WIDTHBYTES(iBmpWidth * bmpInfo.biBitCount);

        if(bmpInfo.biPlanes != 1)

        {

            break;

        }

        if(bmpInfo.biBitCount != 1 && bmpInfo.biBitCount != 4 && bmpInfo.biBitCount != 8 && bmpInfo.biBitCount != 16 && bmpInfo.biBitCount != 24 && bmpInfo.biBitCount != 32)

        {

            break;

        }

        if(bmpInfo.biCompression != BI_RGB && bmpInfo.biCompression != BI_BITFIELDS)

        {

            break;

        }

        if(bmpInfo.biWidth <= 0 || bmpInfo.biHeight == 0)

        {

            break;

        }

        if(bmpHeader.bfOffBits + nBitmapSize > liSize.QuadPart)

        {

            break;

        }



        //m_pR,m_pG,m_pB位BYTE *;

        m_pR = new BYTE[bmpInfo.biWidth * abs(bmpInfo.biHeight)];

        m_pG = new BYTE[bmpInfo.biWidth * abs(bmpInfo.biHeight)];

        m_pB = new BYTE[bmpInfo.biWidth * abs(bmpInfo.biHeight)];



        if(bmpInfo.biBitCount < 16)

        {

            //...

        }

        else if(bmpInfo.biBitCount == 16)

        {

            //...

        }

        else if(bmpInfo.biBitCount == 24)

        {

            ::SetFilePointer(bmpFile, bmpHeader.bfOffBits, NULL, SEEK_SET);



            BYTE *pData;

            pData = new BYTE[nBitmapSize];



            DWORD dwByteRead = 0;

            dwByteRead = 0;

            ::ReadFile(bmpFile, pData, nBitmapSize, &dwByteRead, NULL);



            //pR, pG, pB是临时指针

            BYTE *pR = m_pR;

            BYTE *pG = m_pG;

            BYTE *pB = m_pB;



            for(int j = 0; j < abs(bmpInfo.biHeight); j++)

            {

                BYTE *pTemp = pData + WIDTHBYTES(bmpInfo.biWidth * bmpInfo.biBitCount) * j;

                for(int i = 0; i < bmpInfo.biWidth; i++)

                {

                    *pB++ = *pTemp++;

                    *pG++ = *pTemp++;

                    *pR++ = *pTemp++;

                }

            }



            delete[] pData;

        }

        else if(bmpInfo.biBitCount == 32)

        {

            //...

        }

 

b. 转化,从24位转化成16位

//新文件的头信息

    BITMAPFILEHEADER bmfh;

    BITMAPINFOHEADER bmih;



    memset(&bmfh, 0, sizeof(bmfh));

    memset(&bmih, 0, sizeof(bmih));



    int nBitmapSize = abs(bmpInfo.biHeight) * WIDTHBYTES(bmpInfo.biWidth * 16);

    length = nBitmapSize;

    bmfh.bfType = 'MB';

    bmfh.bfOffBits = sizeof(bmfh) + sizeof(bmih) + 12;

    bmfh.bfSize = bmfh.bfOffBits + nBitmapSize;



    bmih.biSize = sizeof(bmih);

    bmih.biWidth = bmpInfo.biWidth;

    bmih.biHeight = bmpInfo.biHeight;

    bmih.biPlanes = 1;

    bmih.biBitCount = 16;

    bmih.biCompression = BI_BITFIELDS;

    bmih.biSizeImage = nBitmapSize;



    /* 转化后的颜色表保存在pData中 */

    BYTE *pData;

    pData = new BYTE[nBitmapSize];

    memset(pData, 0, nBitmapSize);



    myData = new char[nBitmapSize];

    memset(myData,0,nBitmapSize);



    char * inverseData = new char[nBitmapSize];

    memset(inverseData, 0, nBitmapSize);



    BYTE *pR = m_pR;

    BYTE *pG = m_pG;

    BYTE *pB = m_pB;



    /* 以下是转化的核心代码 */

    /* 转化过程图像的宽和高是不变的，变得是每个像素点从3个字节变成了2个字节 */

    for(int j = 0; j < abs(bmih.biHeight); j++)

    {

        /* 临时指针pTemp 每次从新的一行开始 */

        WORD *pTemp = (WORD *)(pData + WIDTHBYTES(bmih.biWidth * 16) * j);



        for(int i = 0; i < bmih.biWidth; i++)

        {

#if 0

            *pTemp++ = ((WORD)(*pR++ << 8) & 0xf800) | ((WORD)(*pG++ << 3) & 0x07e0) | ((WORD)(*pB++ >> 3) & 0x001f);

#else

            /* 分别去掉低3,2,3位 */

            int nR = (*pR++ + 4) >> 3;

            int nG = (*pG++ + 2) >> 2;

            int nB = (*pB++ + 4) >> 3;

            /* nR位5位，不能超过31，nG为6位，不能超过63，nB同nR */

            if(nR > 31) nR = 31;

            if(nG > 63) nG = 63;

            if(nB > 31) nB = 31;

            /* 将新的R,G,B数据拼到2个字节里，比例为5:6:5 */

            *pTemp++ = (nR << 11) | (nG << 5) | nB;

#endif

        }

    }

 

3. 将图片上下对称翻转。图像点阵是image_width * image_height 的大小，翻转时只需要将 上下两半对应的位置的点对换就行了。经上面的转换后，图像中每个点占2个字节了，所以每个点换两个字节就行。

　　int image_width = bmih.biWidth;

    int image_height = bmih.biHeight;

    int index = 2;//表示16色，占2个字节

    for(int h = 0; h < image_height/2; h++)

        for (int w = 0; w < image_width; w++)

        {

            /* iCoordM 和 iCoordN分别是上下对称的点在颜色表字节数组中的坐标,

                交换iCoordM位置和iCoordM+1位置2个字节就行了。

            */

            const int iCoordM = index*(h*image_width + w);

            const int iCoordN = index*((image_height - h -1)*image_width + w);

            BYTE Tmp = pData[iCoordM];

            pData[iCoordM] = pData[iCoordN];

            pData[iCoordN] = Tmp;

            Tmp = pData[iCoordM+1];

            pData[iCoordM + 1] = pData[iCoordN + 1]; 

            pData[iCoordN + 1] = Tmp;

            /*如果是24位图像，就加上下面的内容，就是再交换一个字节*/

            /*Tmp = pData[iCoordM + 2];

            pData[iCoordM + 2] = pData[iCoordN + 2];

            pData[iCoordN + 2] = Tmp;*/

        }

 

4.  缩放 

 

/* new_heigth和new_width为目标图片的大小，可自定义 */

    int new_height = 430;

    int new_width = 160;

    int newSize = new_width*new_height*2;

    length = newSize;

    BYTE * newData = new BYTE[newSize];

    /* 分配新的内存 */

    memset(newData, 0, new_width*new_height*2);



    for(int h = 0; h < image_height; h++)

        for (int w = 0; w < image_width; w++)

        {

            /* 计算每个像素的起始位置 */

            const int iCoordM = index * (h * image_width + w);

            //const int iCoordN = index*((image_height - h -1)*image_width + w);

            BYTE Tmp = pData[iCoordM];

            int x = int( double(h)/image_height * new_height);//新行数

            int y = int( double(w)/image_width  * new_width);//新列数



            /* 将原来图片的每个像素按比例位置映射到新的图片上 

            原来的位置是(w, h),通过比例就可以计算出新的位置是 

            (int(double(w)/image_width*new_width), int(double(h)/image_height*new_height)),

            然后将新的位置开始的2个字节等于原来位置的2个字节,就完成了缩放。    

            */

            newData[(x*new_width + y)*2] = Tmp;

            newData[(x*new_width + y)*2 + 1] = pData[iCoordM+1];

        }

(完)