rgba/rgb 转bmp文件

最新推荐文章于 2023-05-05 20:35:53 发布
最新推荐文章于 2023-05-05 20:35:53 发布
阅读量975 收藏 1
点赞数
文章标签： p2p 蓝桥杯 gnu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gc286339554/article/details/121818445
版权

#include <stdio.h>  
#include <stdlib.h>  

typedef struct
{
    //unsigned short    bfType;  
    unsigned long    bfSize;
    unsigned short    bfReserved1;
    unsigned short    bfReserved2;
    unsigned long    bfOffBits;
} ClBitMapFileHeader;

typedef struct
{
    unsigned long  biSize;
    long   biWidth;
    long   biHeight;
    unsigned short   biPlanes;
    unsigned short   biBitCount;
    unsigned long  biCompression;
    unsigned long  biSizeImage;
    long   biXPelsPerMeter;
    long   biYPelsPerMeter;
    unsigned long   biClrUsed;
    unsigned long   biClrImportant;
} 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);


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+");
    if (!pFile)
    {
        free(bmpImg);
        return NULL;
    }

    fread(&fileType, sizeof(unsigned short), 1, pFile); 
    if (fileType == 0x4D42) //string "BM"
    {
        //printf("bmp file! \n");  

        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);*/

        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");*/

        if (bmpInfoHeader.biBitCount == 8)
        {
            //printf("该文件有调色板，即该位图为非真彩色\n\n");  
            channels = 1;
            width = bmpInfoHeader.biWidth;
            height = bmpInfoHeader.biHeight;
            offset = (channels*width) % 4;
            if (offset != 0)
            {
                offset = 4 - offset;
            }
            //bmpImg->mat = kzCreateMat(height, width, 1, 0);  
            bmpImg->width = width;
            bmpImg->height = height;
            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);
                    bmpImg->imageData[(height - 1 - i)*step + j] = pixVal;   //每次一个像素处理
                }
                if (offset != 0)
                {
                    for (j = 0; j<offset; j++)
                    {
                        fread(&pixVal, sizeof(unsigned char), 1, pFile);
                    }
                }
            }
        }
        else if (bmpInfoHeader.biBitCount == 24)
        {
            //printf("该位图为位真彩色\n\n");  
            channels = 3;
            width = bmpInfoHeader.biWidth;
            height = bmpInfoHeader.biHeight;

            bmpImg->width = width;
            bmpImg->height = height;
            bmpImg->channels = 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;
            }

            fseek(pFile, bmpFileHeader.bfOffBits - sizeof(bmpInfoHeader) - sizeof(bmpFileHeader), SEEK_CUR);  //138-54?感觉应该没有138才对啊

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

    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");
    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 != 4)
        {
            step += 4 - 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);

        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 != 4)
        {
            step += 4 - 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);

        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;

}

int rgb24_to_bmp(const char *rgb24path,const char *bmppath,int width,int height)
{
    //定义相应的bmp数据头结构体
    typedef struct 
    {  
        long imageSize;
        long blank;
        long startPosition;
    }BmpHead;

    typedef struct
    {
        long  Length;
        long  width;
        long  height;
        unsigned short  colorPlane;
        unsigned short  bitColor;
        long  zipFormat;
        long  realSize;
        long  xPels;
        long  yPels;
        long  colorUse;
        long  colorImportant;
    }InfoHead;
    
    int i=0,j=0;
    BmpHead m_BMPHeader={0};
    InfoHead  m_BMPInfoHeader={0};
    char bfType[2]={'B','M'};
    int header_size=sizeof(bfType)+sizeof(BmpHead)+sizeof(InfoHead);
    unsigned char *rgb24_buffer=NULL;
    FILE *fp_rgb24=NULL,*fp_bmp=NULL;
    
    if((fp_rgb24=fopen(rgb24path,"rb"))==NULL){
        printf("Error: Cannot open input RGB24 file.\n");
        return -1;
    }
    if((fp_bmp=fopen(bmppath,"wb"))==NULL){
        printf("Error: Cannot open output BMP file.\n");
        return -1;
    }
    
    rgb24_buffer=(unsigned char *)malloc(width*height*3);
    fread(rgb24_buffer,1,width*height*3,fp_rgb24);

    //设置相应的bmp头数据结构
    m_BMPHeader.imageSize=3*width*height+header_size;
    m_BMPHeader.startPosition=header_size;

    m_BMPInfoHeader.Length=sizeof(InfoHead); 
    m_BMPInfoHeader.width=width;
    //BMP storage pixel data in opposite direction of Y-axis (from bottom to top).
    m_BMPInfoHeader.height=-height;
    m_BMPInfoHeader.colorPlane=1;
    m_BMPInfoHeader.bitColor=24;
    m_BMPInfoHeader.realSize=3*width*height;

    fwrite(bfType,1,sizeof(bfType),fp_bmp);
    fwrite(&m_BMPHeader,1,sizeof(m_BMPHeader),fp_bmp);
    fwrite(&m_BMPInfoHeader,1,sizeof(m_BMPInfoHeader),fp_bmp);

    //BMP save R1|G1|B1,R2|G2|B2 as B1|G1|R1,B2|G2|R2
    //It saves pixel data in Little Endian
    //So we change 'R' and 'B'
    for(j =0;j<height;j++){
        for(i=0;i<width;i++){
            char temp=rgb24_buffer[(j*width+i)*3+2];
            rgb24_buffer[(j*width+i)*3+2]=rgb24_buffer[(j*width+i)*3+0];
            rgb24_buffer[(j*width+i)*3+0]=temp;
        }
    }
    //写入相应的bmp数据值部分
    fwrite(rgb24_buffer,3*width*height,1,fp_bmp);
    fclose(fp_rgb24);
    fclose(fp_bmp);
    free(rgb24_buffer);
    printf("Finish generate %s!\n",bmppath);
    return 0;
}

int rgba32_to_bmp(const char *rgba32path,const char *bmppath,int width,int height)
{
    //定义相应的bmp数据头结构体
    typedef struct 
    {  
        long imageSize;
        long blank;
        long startPosition;
    }BmpHead;

    typedef struct
    {
        long  Length;
        long  width;
        long  height;
        unsigned short  colorPlane;
        unsigned short  bitColor;
        long  zipFormat;
        long  realSize;
        long  xPels;
        long  yPels;
        long  colorUse;
        long  colorImportant;
    }InfoHead;
    
    int i=0,j=0;
    BmpHead m_BMPHeader={0};
    InfoHead  m_BMPInfoHeader={0};
    char bfType[2]={'B','M'};
    int header_size=sizeof(bfType)+sizeof(BmpHead)+sizeof(InfoHead);
    unsigned char *rgba32_buffer=NULL;
    unsigned char *rgb24_buffer=NULL;
    FILE *fp_rgba32=NULL,*fp_bmp=NULL;
    
    if((fp_rgba32=fopen(rgba32path,"rb"))==NULL){
        printf("Error: Cannot open input RGB24 file.\n");
        return -1;
    }
    if((fp_bmp=fopen(bmppath,"wb"))==NULL){
        printf("Error: Cannot open output BMP file.\n");
        return -1;
    }
    
    rgba32_buffer=(unsigned char *)malloc(width*height*4);
    rgb24_buffer=(unsigned char *)malloc(width*height*3);
    fread(rgba32_buffer,1,width*height*4,fp_rgba32);
    for (int i=0; i<width*height; i++) {
        rgb24_buffer[i * 3 + 0] = rgba32_buffer[i*4+0];
        rgb24_buffer[i * 3 + 1] = rgba32_buffer[i*4+1];
        rgb24_buffer[i * 3 + 2] = rgba32_buffer[i*4+2];
    }

    //设置相应的bmp头数据结构
    m_BMPHeader.imageSize=3*width*height+header_size;
    m_BMPHeader.startPosition=header_size;

    m_BMPInfoHeader.Length=sizeof(InfoHead); 
    m_BMPInfoHeader.width=width;
    //BMP storage pixel data in opposite direction of Y-axis (from bottom to top).
    m_BMPInfoHeader.height=-height;
    m_BMPInfoHeader.colorPlane=1;
    m_BMPInfoHeader.bitColor=24;
    m_BMPInfoHeader.realSize=3*width*height;

    fwrite(bfType,1,sizeof(bfType),fp_bmp);
    fwrite(&m_BMPHeader,1,sizeof(m_BMPHeader),fp_bmp);
    fwrite(&m_BMPInfoHeader,1,sizeof(m_BMPInfoHeader),fp_bmp);

    //BMP save R1|G1|B1,R2|G2|B2 as B1|G1|R1,B2|G2|R2
    //It saves pixel data in Little Endian
    //So we change 'R' and 'B'
    for(j =0;j<height;j++){
        for(i=0;i<width;i++){
            char temp=rgb24_buffer[(j*width+i)*3+2];
            rgb24_buffer[(j*width+i)*3+2]=rgb24_buffer[(j*width+i)*3+0];
            rgb24_buffer[(j*width+i)*3+0]=temp;
        }
    }
    //写入相应的bmp数据值部分
    fwrite(rgb24_buffer,3*width*height,1,fp_bmp);
    fclose(fp_rgba32);
    fclose(fp_bmp);
    free(rgb24_buffer);
    printf("Finish generate %s!\n",bmppath);
    return 0;
}

int main(int argc, char* argv[])
{
    //All picture's resolution is 1280x720
    //Gray Bar, from 16 to 235
    for (int a=87; a<500; a++) {
        char buff[128] = {0};
        char buff1[128] = {0};
        sprintf(buff,"rgba_%d.rgba",a);
        sprintf(buff1,"rgba_%d.bmp",a);
        rgba32_to_bmp(buff,buff1,3840,1920);
    }
    
    return 0;
}
/*
int main(int argc, char* argv[]) {


    FILE* FFF = fopen(argv[1],"r+");

    ClImage  bbb;
        bbb.width = 3840;
        bbb.height = 1920;
        bbb.channels = 3;
        bbb.imageData = new unsigned char[3840*1920*3];
        char rrr[4] = {0};
    
        for (size_t j = 0; j < 3840*1920; j++)
        {
            fread(rrr,4,1,FFF);
            bbb.imageData[j * 3 + 0] = rrr[0];
            bbb.imageData[j * 3 + 1] = rrr[1];
            bbb.imageData[j * 3 + 2] = rrr[2];
        }
        fclose(FFF);
        char buf[128] = {0};
                
                sprintf(buf,"%s.bmp",argv[1]);
                clSaveImage(buf,&bbb);
                getchar();
    return 0;
}*/

GC286339554
关注
Linux平台C语言保存RGB数据为BMP文件
lichaofan2008的博客
12-17 1517
在图像处理领域，RGB格式是经常使用的一种格式，BMP格式文件是较常见的一种图像文件。
RGBA数据使用c++存本地bmp文件
yangzm的专栏
05-02 1368
我从内存中的位图想得到其中的buffer数据，而且是32位的rgba 格式的，用下边的函数： 内存中的位图得buffer的方法：其中的回调可以得到数据 void CPaintManagerUI::BitmapCreate(HWND hWnd,HDC dc) { HDC hdcWindow; HDC hdcMemDC = NULL; HBITMAP hbmScreen = NULL; ...
RGBA数据转存BMP图片
09-06
RGBA数据转存BMP图片。。。。。。。。。。。。。。。。。。。。 只有一个头文件，3个函数，包含使用即可。。。。。。。。。。。。。。。。。。
将纯净的摄像头RGB数据转为bmp
gujvihhui的博客
04-29 237
利用VS2013使用C语言实现。 #include<stdio.h> #include<stdlib.h> #pragma warning(disable:4996) #pragma pack(1)//结构体字节对齐，必须有 typedef struct tagBITMAPFILEHEADER { unsigned short bfType;//2WORD unsigned short bfReserved1;//2WORD unsigned long bf.
将rgba图片信息转换为bmp图片文件
G_Super_Mouse的博客
11-18 1543
将rgba图片信息转换为bmp图片文件 #include <stdio.h> #include <windows.h> #pragma pack(1) //BMP文件头（14字节） typedef struct /**** BMP file header structure ****/ { unsigned int bfSize; /* Size of file */ unsigned short bfRes
RGB24/RGBA生成BMP图片代码
07-14 2666
转自：(14条消息) RGB数据保存为BMP图片_yixianfeng41的专栏-CSDN博客 一、BMP文件由文件头、位图信息头、颜色信息和图形数据四部分组成。 1、BMP文件头（14字节） typedef struct /**** BMP file header structure ****/ { unsigned int bfSize; /* Size of file */ unsigned sho
C语言将raw data(rgb/rgba)写成bmp文件(bmp24或32)
红尘孤灯
08-12 2715
int bmp_write(unsigned char *image, int xsize, int ysize, char *filename) {    unsigned char header[54] = {      0x42, 0x4d, 0, 0, 0, 0, 0, 0, 0, 0,        54, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0,
RGBreader.zip_C++读取bmp rgb_bmp RGB
07-14
4. **解析图像数据**：BMP文件中的像素数据是按行存储的，每个像素通常由3字节（RGB）或4字节（RGBA，包含透明度通道）组成。根据颜色深度，我们可以计算出图像数据的总大小。然后，我们可以逐行读取数据，每次读取...
Linux 下V4l2摄像头采集图片，实现yuyv转RGB,RGB转BMP，RGB伸缩，RGB转JPEG（保存到内存中），JPEG经UDP发送功能
10-27
ARM Cortex-A8平台Linux下V4l2摄像头采集图片程序，实现yuyv转RGB,RGB转BMP保存，RGB缩放等功能。利用jpeglib实现RGB转JPEG，并且压缩结果保存至内存中，无需再用文件操作来保存JPEG图片，JPEG经UDP发送至远程服务器...
BMP图片转RGB数组
12-10
要提取BMP图片的RGB数据并存储到数组，我们首先需要读取BMP文件的头部信息，获取宽度、高度和位深度。然后，我们可以逐行读取位图数据，对于每个像素，我们根据位深度解码其RGB值。在24位BMP中，每个像素占据3个字节...
RGB转BMP工具和源码
11-20
RGB转成BMP的工具和工程源码，实现了rgb图像转换成BMP图像，支持32_ARGB、16_RGB565和16_RGB555三种格式的转换
24位RGB数据保存为BMP图片
06-18
实现过程： A、写入文件头 B、写入信息头 C、写入图像RGB数据 （无调色板） 亲测可以使用
RGB格式转为BMP格式
04-08
RGB格式的文件添加BMP头信息，C代码
RGB数据生成BMP图片
05-24
当你想生成一个BMP图片却屡屡失败时，有没有很烦恼、很受挫，想要抓狂的赶脚，我想肯定有的.......怎么办了，用用我这个测试列子测试一下吧。这个测试程序，包含了生成RGB数据的方法和将RGB数据生成BMP图片的方法，你可以通过这个方法找到到底是你RGB数据的问题了，还是你生成BMP图片方法的问题
单片机c语言编程RGB,C语言将raw data(rgb/rgba)写成bmp文件(bmp24或32)
weixin_33766046的博客
05-18 300
int bmp_write(unsigned char *image, int xsize, int ysize, char *filename){unsigned char header[54] = {0x42, 0x4d, 0, 0, 0, 0, 0, 0, 0, 0,54, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 32(或者24...
C++ 将RGB像素数据封装为BMP图像
最新发布
qq_51214753的博客
05-05 1302
最近在从零学习音视频，在看雷神的教学帖，雷神通过c去将RGB像素数据封装为BMP图像，在这里通过c++进行一个简单的复现。也记录一下自己的音视频之路。
RGB数据保存为BMP图片
lmrylll的博客
04-24 976
颜色表中的RGBQUAD结构数据的个数由biBitCount来确定：当biBitCount=1,4,8时，分别为2,16,256个表项；当biBitCount=24时，没有颜色表项。颜色表用于说明位图中的颜色，它有若干个表项，每一个表项是一个RGBQUAD类型的结构，定义一种颜色。当biBitCount=24时，1个像素占3个字节,按顺序分别为B,G,R；当biBitCount=1时，8个像素占1个字节；当biBitCount=4时，2个像素占1个字节；当biBitCount=8时，1个像素占1个字节；
音视频数据处理入门：rgb转bmp
weixin_43796767的博客
04-26 404
BMP图像内部实际存储的是RGB数据，我们通过添加bmp头部信息，调整RGB分量存储顺序，可以将RGB数据封装得到bmp图像。 1、BMP文件格式： BITMAPFILEHEADER + BITMAPINFOHEADER + RGB像素数据 bmp头部信息： 位图文件头(14字节)：{‘B’,‘M’} + fsize + blank + offset 位图信息头(40字节)：信息头大小，图像宽高、色深，压缩方式，图像数据大小，，， 2、具体的头部信息和转换过程请看下列核心代码： typedef str
C语言解析BMP图像并转换为YUV
`convert_to_yv12`函数是将读取的BMP图像数据（以RGBA格式存储）转换为YV12格式的过程。YV12格式是一种无损的YUV格式，其中Y分量以4:2:0的采样率存储，即每4个像素共享1个U和1个V分量。在这个函数中，`in_ptr`指向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值