一个最简单的Windows BMP位图文件解析程序

已于 2024-09-05 19:20:22 修改
阅读量299 收藏 4
点赞数 8
分类专栏： 编程笔记 文章标签： windows
于 2024-09-05 19:14:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/momomomo90/article/details/141938228
版权

站里讲解BMP格式的文章已经有了，这里主要是分享一个示例程序给需要的同学。这个示例只支持24/32位不带调色板的位图文件解析，并且实现了简单的Resize、亮度调整功能，另外加了一个比较有意思的功能就是把图片转换成RGB像素点的形式（但是输出很容易变得非常大甚至超过4G导致32bit的数值溢出）。
bmp文件有个特点，Windows规定每一行占用字节数必须是4的整数倍，多余的数据用0补足。这个在处理24bit位图时，计算数据索引时需要注意。

bitmap.h

#ifndef _BITMAP_H_
#define _BITMAP_H_

#include "types.h"

#pragma pack(1)
typedef struct tagBITMAPFILEHEADER
{
    UINT16 bfType;
    DWORD bfSize;
    UINT16 bfReserved1;
    UINT16 bfReserved2;
    DWORD bfOffBits;
} BITMAPFILEHEADER;
#pragma pack()

typedef struct tagBITMAPINFO
{
    DWORD biSize;
    DWORD biWidth;
    DWORD biHeight;
    WORD biPlanes;
    WORD biBitCount;
    DWORD biCompression;
    DWORD biSizeImage;
    DWORD biXPelsPerMeter;
    DWORD biYPelsPerMeter;
    DWORD biClrUsed;
    DWORD biClrImportant;
} BITMAPINFO;

#define BMPTYPE_BM 0x4d42
#define blue(color) (BYTE)(color)
#define green(color) (BYTE)((color) >> 8)
#define red(color) (BYTE)((color) >> 16)
#define alpha(color) (BYTE)((color) >> 24)
#define makecolor(b,g,r,a) (((BYTE)(b)) | ((BYTE)(g) << 8) | ((BYTE)(r) << 16) | ((BYTE)(a) << 24) )
#endif

BMP部分：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "types.h"
#include "bitmap.h"

#pragma pack(1)
typedef struct tagBMP
{
    BITMAPFILEHEADER head;
    BITMAPINFO info;
    BYTE data[0];
} BMP;
#pragma pack()

BMP *create_bmp(DWORD w, DWORD h, WORD bitdepth)
{
    DWORD rowsize = (w * bitdepth / 8 + 3) & (~3U);
    DWORD size_image = h * rowsize;
    DWORD file_size = size_image + sizeof(BMP);

    BMP *bmp = malloc(file_size);
    if (bmp == NULL)
    {
        return NULL;
    }
    bmp->head.bfType = BMPTYPE_BM;
    bmp->head.bfSize = file_size;
    bmp->head.bfReserved1 = 0;
    bmp->head.bfReserved2 = 0;
    bmp->head.bfOffBits = sizeof(BMP);
    bmp->info.biSize = sizeof(BITMAPINFO);
    bmp->info.biWidth = w;
    bmp->info.biHeight = h;
    bmp->info.biPlanes = 1;
    bmp->info.biBitCount = bitdepth;
    bmp->info.biCompression = 0;
    bmp->info.biSizeImage = size_image;
    bmp->info.biXPelsPerMeter = 0;
    bmp->info.biYPelsPerMeter = 0;
    bmp->info.biClrUsed = 0;
    bmp->info.biClrImportant = 0;
    return bmp;
}

int save_file(const BMP *bmp, const char *path)
{
    if (bmp == NULL)
        return -1;
    FILE *fp = fopen(path, "wb+");
    if (fp == NULL)
        return -1;
    fwrite(bmp, 1, bmp->head.bfSize, fp);
    fclose(fp);
}

BMP *create_from_file(const char *path)
{
    BITMAPFILEHEADER headtemp;
    FILE *fp = fopen(path, "rb+");
    if (fp == NULL)
        goto except;
    fread(&headtemp, 1, sizeof(BITMAPFILEHEADER), fp);

    BMP *bmp = malloc(headtemp.bfSize);
    if (bmp == NULL)
    {
        goto close_file;
    }
    memcpy(&bmp->head, &headtemp, sizeof(bmp->head));
    fread(&bmp->info, 1, headtemp.bfSize - sizeof(BITMAPFILEHEADER), fp);
    return bmp;

close_file:
    fclose(fp);
except:
    return NULL;
}

void destroy_bmp(BMP **pbmp)
{
    if (pbmp != NULL)
        free(*pbmp);
    *pbmp = NULL;
}

处理函数部分

void rect(BMP *bmp, DWORD color, DWORD row, DWORD col, DWORD w, DWORD h)
{
    DWORD width = bmp->info.biWidth;
    DWORD height = bmp->info.biHeight;
    DWORD colend = MIN(col + w, width);
    DWORD rowend = MIN(row + h, height);
    const DWORD dsize = bmp->info.biBitCount / 8;
    const DWORD rowsize = (width * dsize + 3) & (~3U);
    for (DWORD i = row; i < rowend; i++)
    {
        for (DWORD j = col; j < colend; j++)
        {
            BYTE *data = bmp->data + i * rowsize + j * dsize;
            data[0] = blue(color);
            data[1] = green(color);
            data[2] = red(color);
        }
    }
}

void rect_lightness(BMP *bmp, DWORD row, DWORD col, DWORD w, DWORD h, float ratio)
{
    DWORD width = bmp->info.biWidth;
    DWORD height = bmp->info.biHeight;
    DWORD colend = MIN(col + w, width);
    DWORD rowend = MIN(row + h, height);
    const DWORD dsize = bmp->info.biBitCount / 8;
    const DWORD rowsize = (width * dsize + 3) & (~3U);
    for (DWORD i = row; i < rowend; i++)
    {
        for (DWORD j = col; j < colend; j++)
        {
            BYTE *data = bmp->data + i * rowsize + j * dsize;
            data[0] = color_truncate(((float)data[0]) * ratio);
            data[1] = color_truncate(((float)data[1]) * ratio);
            data[2] = color_truncate(((float)data[2]) * ratio);
        }
    }
}

BYTE color_truncate(int grlevel)
{
    if (grlevel < 0)
        return 0;
    if (grlevel > 255)
        return 255;
    return grlevel;
}

DWORD color_lightness(BYTE b, BYTE g, BYTE r, int delta)
{
    BYTE blue = color_truncate((int)b + delta);
    BYTE green = color_truncate((int)g + delta);
    BYTE red = color_truncate((int)r + delta);
    return makecolor(blue, green, red, 0);
}

DWORD color_lightnessf(BYTE b, BYTE g, BYTE r, float ratio)
{
    BYTE blue = color_truncate(((float)b) * ratio);
    BYTE green = color_truncate(((float)g) * ratio);
    BYTE red = color_truncate(((float)r) * ratio);
    return makecolor(blue, green, red, 0);
}

void lightness(BMP *bmp, int delta)
{
    DWORD width = bmp->info.biWidth;
    DWORD height = bmp->info.biHeight;
    const DWORD dsize = bmp->info.biBitCount / 8;
    const DWORD rowsize = (width * dsize + 3) & (~3U);
    for (DWORD i = 0; i < height; i++)
    {
        for (DWORD j = 0; j < width; j++)
        {
            BYTE *data = bmp->data + i * rowsize + j * dsize;
            data[0] = color_truncate((int)data[0] + delta);
            data[1] = color_truncate((int)data[1] + delta);
            data[2] = color_truncate((int)data[2] + delta);
        }
    }
}

void lightnessf(BMP *bmp, float ratio)
{
    DWORD width = bmp->info.biWidth;
    DWORD height = bmp->info.biHeight;
    const DWORD dsize = bmp->info.biBitCount / 8;
    const DWORD rowsize = (width * dsize + 3) & (~3U);
    for (DWORD i = 0; i < height; i++)
    {
        for (DWORD j = 0; j < width; j++)
        {
            BYTE *data = bmp->data + i * rowsize + j * dsize;
            data[0] = color_truncate((int)data[0] * ratio);
            data[1] = color_truncate((int)data[1] * ratio);
            data[2] = color_truncate((int)data[2] * ratio);
        }
    }
}

BMP *resize(const BMP *bmp, float fscale)
{
    int scale = (int)fscale;
    const DWORD dsize = bmp->info.biBitCount / 8;
    const DWORD w = bmp->info.biWidth;
    const DWORD h = bmp->info.biHeight;
    const DWORD rowsize = (w * dsize + 3) & (~3U);
    DWORD newwidth = bmp->info.biWidth * fscale;
    DWORD newheight = bmp->info.biHeight * fscale;
    DWORD newdsize = 3;
    BMP *newbmp = create_bmp(newwidth, newheight, newdsize * 8);
    DWORD newrowsize = (newwidth * newdsize + 3) & (~3U);
    if (fscale > 1.f)
    {
        for (DWORD i = 0; i < bmp->info.biHeight; i++)
        {
            for (DWORD j = 0; j < bmp->info.biWidth; j++)
            {
                const BYTE *data = bmp->data + i * rowsize + j * dsize;
                DWORD color = makecolor(data[0], data[1], data[2], 0);
                rect(newbmp, color, i * fscale, j * fscale, fscale, fscale);
            }
        }
    }
    else if (fscale < 1.f)
    {

        for (DWORD i = 0; i < newheight; i++)
        {
            for (DWORD j = 0; j < newwidth; j++)
            {
                BYTE *dstdata = newbmp->data + i * newrowsize + j * newdsize;
                const BYTE *data = bmp->data + (DWORD)(i / fscale) * rowsize + (DWORD)(j / fscale) * dsize;
                dstdata[0] = data[0];
                dstdata[1] = data[1];
                dstdata[2] = data[2];
            }
        }
    }
    return newbmp;
}

BMP *resize_screen(const BMP *bmp, WORD frame_width, WORD pixel_width)
{
    int scale = pixel_width * 3 + frame_width * 3;
    const DWORD dsize = bmp->info.biBitCount / 8;
    const DWORD w = bmp->info.biWidth;
    const DWORD h = bmp->info.biHeight;
    const DWORD rowsize = (w * dsize + 3) & (~3U);
    BMP *newbmp = create_bmp(bmp->info.biWidth * scale, bmp->info.biHeight * scale, 24);
    for (DWORD i = 0; i < bmp->info.biHeight; i++)
    {
        DWORD preblue = 0;
        for (DWORD j = 0; j < bmp->info.biWidth; j++)
        {
            const BYTE *data = bmp->data + i * rowsize + j * dsize;
            DWORD color = makecolor(data[0], data[1], data[2], 0);
            DWORD gray = data[2] * 0.3 + data[1] * 0.59 + data[0] * 0.11;
            float diffusion = 0.5;
            DWORD red = makecolor(data[0] * diffusion, data[1] * diffusion, data[2], 0);
            DWORD green = makecolor(data[0] * diffusion, data[1], data[2] * diffusion, 0);
            DWORD blue = makecolor(data[0], data[1] * diffusion, data[2] * diffusion, 0);

            // DWORD frame = color_lightnessf(data[0], data[1], data[2], 0.3);
            float lightness = 0.5;
            DWORD frameRG = color_lightnessf(0, data[1], data[2], lightness);
            DWORD frameGB = color_lightnessf(data[0], data[1], 0, lightness);
            DWORD frameBR = color_lightnessf(preblue, 0, data[2], lightness);
            preblue = blue;
            DWORD frameGray = color_lightnessf(gray, gray, gray, lightness);
            DWORD joffset = 0;
            rect(newbmp, frameBR, i * scale, j * scale, frame_width, scale);
            joffset += frame_width;
            rect(newbmp, red, i * scale, j * scale + joffset, pixel_width, scale);
            joffset += pixel_width;
            rect(newbmp, frameRG, i * scale, j * scale + joffset, frame_width, scale);
            joffset += frame_width;
            rect(newbmp, green, i * scale, j * scale + joffset, pixel_width, scale);
            joffset += pixel_width;
            rect(newbmp, frameGB, i * scale, j * scale + joffset, frame_width, scale);
            joffset += frame_width;
            rect(newbmp, blue, i * scale, j * scale + joffset, pixel_width, scale);
            joffset += pixel_width;
            rect_lightness(newbmp, i * scale, j * scale, scale, frame_width, lightness);
        }
    }
    return newbmp;
}

测试程序：

int main(int argc, char *argv[])
{
    // BMP *bmp = create_bmp(100, 100, 24);
    // save_file(bmp, "1.bmp");
    // destroy_bmp(&bmp);

    BMP *bmp = create_from_file("test.bmp");
    BMP *bmpre = resize_screen(bmp, 1, 2);
    // BMP *bmps = resize(bmpre, 0.5f);
    lightnessf(bmpre, 1.2);
    save_file(bmpre, "test1.bmp");
    destroy_bmp(&bmp);
    // destroy_bmp(&bmps);
    destroy_bmp(&bmpre);

    return 0;
}

原图
请添加图片描述
处理后（裁剪）
请添加图片描述

糖少主
关注
  • 8
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一个可以显示BMP位图的程序
12-28
总之，“ShowDib”是一个专门用于显示BMP位图的程序，通过对BMP文件结构的理解和解析，实现了对图像数据的读取和在屏幕上的呈现。如果你需要查看BMP文件，这是一个简单且直接的选择，尤其适用于那些对图像格式转换和...
浅析BMP位图文件结构（含Demo）
weixin_34248705的博客
11-21 91
浅析BMP位图文件结构（含Demo） 作者：一点一滴的Beer http://beer.cnblogs.com/       关于BMP位图格式在网上可以找到比较详细的相关文档，有兴趣的可以搜索标题为“BMP文件结构的探索”的文章，可以在搜索结果中找到一个WORD文档，里面有很详细的介绍。很感谢这个文档的作者（ID是WhatIf），总结得很详细而且还附有详细的应用代码（文档我会放在本文最后面...
BMP文件格式解析
水木子的博客
11-08 5677
BMP文件格式解析 作者：水木子 一、图像概述 1.1 位图 位图（Bitmap），又称栅格图（英语：Raster graphics）或点阵图，是使用像素阵列来表示的图像。 ----维...
位图(bmp)文件格式分析
weixin_41336592的博客
11-15 1万+
from：https://blog.csdn.net/qingchuwudi/article/details/25785307 位图(bmp)文件格式分析 作者：深蓝（由博主分享） 一、什么是位图 计算机能以位图和矢量图格式显示图像。 1、位图(Bitmap)： 图像又称点阵图或光栅图，它使用我们称为像素(象素，Pixel)的一格一格的小点来描述图像。计算机屏幕其实就是一张包含大量像素点的网格。当我们把位图放大时，每一个像素小点看上去就像是一个个马赛克色...
BMP文件格式详解（BMP file format）
热门推荐
z2bns的博客
08-24 1万+
BMP文件格式，又称为Bitmap（位图）或是DIB(Device-Independent Device，设备无关位图)，是Windows系统中广泛使用的图像文件格式。由于它可以不作任何变换地保存图像像素域的数据，因此成为我们取得RAW数据的重要来源。Windows的图形用户界面（graphical user interfaces）也在它的内建图像子系统GDI中对BMP格式提供了支持。 下面以Notepad++为分析工具，结合Windows的位图数据结构对BMP文件格式进行一个深度的剖析。 BMP文件.
BMP文件格式详解
hulinhulin的专栏
09-17 858
本文转载自：https://www.cnblogs.com/wainiwann/p/7086844.html BMP文件格式详解（BMP file format） BMP文件格式，又称为Bitmap（位图）或是DIB(Device-Independent Device，设备无关位图)，是Windows系统中广泛使用的图像文件格式。由于它可以不作任何变换地保存图像像素域的数据，因此成为我们取得R...
解析BMP格式图片
最新发布
m0_46239139的博客
07-05 751
解析bmp，获取bmp中的像素值，了解bmp的结构
BMP文件格式的解析和保存
JavaFresh
09-16 633
    BMP是英文Bitmap（位图）的简写，它是Windows操作系统中的标准图像文件格式，能够被多种Windows应用程序所支持。因为几乎不进行压缩，所以BMP格式是最简单的通用格式之一。   本篇文章主要介绍BMP文件的格式规范，解析及其保存。        BMP文件结构（本段代码由小组成员卿雯童鞋呈现）   位图文件可看成由4个部分组成：位图文件头（bitmap-fil...
解析BMP格式文件，并实现重绘
u012763405的博客
05-18 215
                    我们看到一张图片，无论是什么格式的，都是用图片浏览器打开的，强大的浏览器 可以解析各种格式图片。例如jpg，bmp，gif，png，等等，这里我们讲一下解析较为简单的BMP格式，首先准备一张bmp格式的图片，  然后UltraEdit软件解析，出来会是这个样子   接下来对照下表解析以上字节意思，注意以上都是16进制，学会使用计算器进行转换成10进...
BMP.rar_bmp_bmp位图_bmp保存_bmp文件保存_保存bmp
09-20
BMP位图文件是一种常见的图像文件格式，广泛应用于各种操作系统和应用程序中。它的全称是Bitmap，源自Microsoft Windows操作系统，但已经成为了跨平台的标准。在本文中，我们将深入探讨BMP位图文件的结构、如何读取...
BMP位图处理类源码.zip_bmp_bmp位图_bmp处理_c bmp_位图
09-23
`BmpProc.cpp` 和 `BmpProc.h` 是两个关键文件，它们构成了一个简单的C++库，用于读取、写入和操作BMP位图。`BmpProc.cpp`包含了函数的具体实现，而`BmpProc.h`则定义了相关的函数接口和结构体，便于在其他程序中...
位图BMP格式图像文件处理类源码VC版.rar_bmp_vc 文件读写_位图 VC_位图读写操作_文件读写
09-21
位图BMP（Bitmap）格式是Windows操作系统中最基础的图像文件格式之一，它以未经压缩的原始像素数据存储图像。在VC++环境下，处理BMP文件通常涉及到文件的读写操作，以及对图像数据的解析和操作。这个“位图BMP格式...
Qt下实现录制麦克风声音
momomomo90的博客
07-13 1806
先上header，header是灵魂 有一些是没用的。 #ifndef WIDGET_H #define WIDGET_H #include <QWidget> #include <QString> #include <QFile> #include <QAudio> #include <QAudioFormat> #include &...
使用Win32 API绘制wav文件波形
momomomo90的博客
10-25 1020
最近想把Win32 GDI绘图捡回来一些。在CFree下写了一个读取16-bit int PCM wav文件并在窗口中绘制波形的小程序。总结一下主要的收获： 1. Windows资源文件.rc 以前在Visual Studio下编写Win32和MFC程序，rc文件都是自动生成。这次用CFree写程序，条件不允许，就需要自己编辑了。这次主要用到rc文件添加菜单。 IDC_WIN32WNDEMO MENU BEGIN POPUP "文件(&F)" BEGIN MENUITEM "打开(&
创建一个简单的VST之Channel Mixer
momomomo90的博客
03-30 964
创建一个简单的VST之Channel Mixer 上次做了一个将数据直接透传的VST插件，意在熟悉VST SDK的开发过程。这次在之前的基础上，实现简单的声道重混缩功能。本来只想做调节音量功能来做练习，后来发现拓展个声道重混缩功能也是顺水推舟的事。 和上次相比不同的是，这次需要增加可调的参数。考虑一个Channel Mixer的功能，需要以下几个参数： 左声道输出的左声道比例、右声道比例 右声道输...
C语言中short int的移位操作
momomomo90的博客
10-28 700
SINT16 s16_val = fpga_spi_read(reg, addr); printf("value = %d\n", s16_val); 新同事问我一个问题，说FPGA给的9-bit有符号数，打印出来是个正数。我一看，9 bit的有符号数对short来说接收下来高7位肯定全是0，于是想当然地帮他改成了： SINT16 s16_val = fpga_spi_read(reg, addr); s16_val = (s16_val << 7) >> 7; prin.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值