BMP和JPEG - 附截屏保存为JPG源码

最新推荐文章于 2024-07-08 18:04:07 发布

Martin89

最新推荐文章于 2024-07-08 18:04:07 发布

阅读量817

点赞数

1. 什么是 BMP
BMP 格式是最简单,最直观的位图数据格式.它的思想非常朴素:
用若干个位来保存一个像素的信息,由若干个像素组成一个像素流来表达一张图片.
通常我们会用1位(可以保存2种颜色,0 表示一种颜色,1表示另一种,不一定是黑白,也可以是蓝绿,总之是2种),4位 - 16种颜色,8位 - 256种颜色,16位 - 65535种颜色,24位 - 2^24种颜色,32位 - 前24位和24位位图一样可以保存2^24种颜色,最后8位用来保存这个像素的灰度(也就是这个像素的明暗程度),可以表示256种灰度.注意,目前的显示器在硬件上通常只能支持24位色,而且 libjpeg 也只能处理最多24位色的像素流.

对于24位以下的BMP,可以引入一个"调色板"来增强图片的表达能力,以8位,256色位图作为例子:
在8位位图中,每个像素的信息用一个字节存储,那么 DIB 数据就是一个 BYTE dibBuffer[] 数组, dibBuffer[0] 表示第一个像素的颜色,以此类推. 我们知道颜色是由RGB 3个分量组合而成的,编程中用 RGBQUAD 结构表示,那么8位除以3,每个分量只能用2位来存储(不使用编码压缩RLE的前提下),实际能够表现的颜色非常有限.现在我们引入一个长度为256的 RGBQUAD 类型的数组: RGBQUAD colorTable[256],我们在 DBI 数组 dibBuffer[] 中不再直接存放的每个像素的颜色值,而是存放该颜色值在 colorTable 中的索引,这样就可以充分利用 dibBuffer 中的每一位的存储空间.这个 "colorTable" 就是 Windows 中调色板的概念. 知道了这些,就可以理解为什么24位及以上色深的位图不需要调色板了.

2.1. BMP 文件格式和DIB
DIB就是"设备无关位图"的意思,我们可以理解为一个像素数组,这是编程时我们需要处理的数据,非常简单,就是一个定长数组,如果是一个24位的DIB数据,那么在编程时就可以认为是一个 BYTE dibBuffer[], dibBuffer[0],dibBuffer[1],dibBuffer[2]表示第一个像素的 RGB 值(实际上是 BGR), dibBuffer[3],[4],[5] 表示第二个像素的 RGB 值,以此类推.当然我们不能直接把这个 dibBuffer 数组写到磁盘作为 BMP 文件,缺少图片的调色板,宽,高等信息,所以我们需要一个特定的格式来存储 DIB 像素流.

BMP文件格式就是把DIB像素流存储到磁盘是需要遵循的相关约定. 关于BMP文件格式的详细说明在网上可以找到很多,比如这篇说的就很清楚: http://blog.csdn.net/lanbing510/article/details/8176231
从编程的角度来看,一个BMP文件是可以表述为以下结构:
typedef struct tagBITMAP_FILE
{
      BITMAPFILEHEADER bitmapheader;
      BITMAPINFOHEADER bitmapinfoheader;
      PALETTEENTRY palette[n]; // 调色板数据(可选,由BITMAPFILEHEADER::bOffBits计算 n 的值)
      UCHAR *dibBuffer;   // DIB 数据数组
} BITMAP_FILE;
BITMAPFILEHEADER, BITMAPINFOHEADER, PALETTEENTRY 结构的详细信息可以在 MSDN 中查到.

用自然语言简单描述一下:
文件头 - 固定长度,表示这个文件是一个 BMP 文件,版本号,文件长度等,最重要的时文件头结构中的 bfOffBits 字段,它表示 DIB 像素流数据在文件中的偏移位置,编程时,我们打开一个 BMP 文件,先读取固定长度的文件头,在根据这个字段就可以构造前面说的调色板数组 RGBQUAD colorTable[] 和 DIB 数组 BYTE dibBuffer[] 了.
BMP信息头 - 固定长度,存储位图的宽高等信息,需要注意的字段 biHeight, 如果它是正数则表示像素流的信息是倒序存储的,即位图的底下一行的像素存储在前;如果它是负数则表示像素流的信息是正序存储的,位图的第一行像素存储在 dibBuffer 开头.
调色板数组 - 可选,用文件头中的偏移地址减去文件头和信息头的长度就是调色板数组的长度.
DIB像素流 - 就是 dibBuffer[] 数组.
特别要注意的一点是,在实际编程中, 24位 DIB 数据的存放顺序是 BGR 即 dibBuffer[0] 存放的是最后一行的第一个像素的 B 分量, dibBuffer[1] 是 G 分量, dibBuffer[2] 是 R 分量, 而 JPG 压缩时要求输入顺序是 RGB, 所以把 dibBuffer 提供给 JPEG 压缩器前需要处理一下, dibBuffer[i] 和 dibBuffer[i + 2] 交换,否则得到的 JPG 图像颜色是不对的.

2.2. DDB
DDB 是"设备相关位图"的意思,把 DIB 数据写入设备之后,设备在内部会把 DIB 数据处理为内部数据格式, Windows GDI 中用 HBITMAP 表述一个 DDB,我们只需要调用相关的 API 就可以了,具体细节不用理会.

3. 什么是 JPEG
JPEG是 DIB 数据的一种编码规则,前面我们提到 BMP 文件,直接把 DIB 数组 dibBuffer[] 直接写到文件中,所以BMP文件是原始的,无损失的保存了内存中的图像数据.如果用某种算法把 dibBuffer 数组编码压缩,那么我们也许就没必要把整个 dibBuffer (通常是一个很大的数组) 直接写入文件中,从而大大节省磁盘空间. JPEG 就是这样一种算法.

4. libjpeg
C语言实现的 JPEG 库,官网地址: http://www.ijg.org/

4.1 编译
我写这篇文章的时候 JPEG 库的版本是 jpeg-9b,从官网上下载源码 jpegsr9b.zip 解压后,启动Visual Studio,进入命令行模式,切换到 jpeg 源码目录,输入: nmake /f makefile.vc 就会看到 jpeg.sln - VS工程文件出现了,用Visual Studio 打开编译即可.
如果执行 nmake 命令时提示找不到 win32.mak,就编辑一下 makefile.vc 把第12行 !include <win32.mak> 注释掉就可以,其实 nmake /f makefile.vc 并不是真正编译,这是重命名了几个文件而已.
编译完成后得到: jpeg.lib 这就是你需要的库文件了,再把 jconfig.h, jerror.h, jinclude.h, jmorecfg.h, jpeglib.h 复制到你的工程中就算配置完成了.

4.2 example.c
libjpeg 的使用实例在源码包中的 example.c 文件里, 我们只要把 write_JPEG_file / read_JPEG_file 两个函数看明白就可以应付大多数应用.

4.3 内存 JPG 压缩解压缩及其它
example.c 中的实例是使用文件io的, 用 jpeg_mem_src / jpeg_mem_dest 函数代替 jpeg_stdio_src / jpeg_stdio_dest 就可以实现内存io.

JPEG库是不知道调色板之类的东西的,它只是很单纯的把输入的 DIB 像素流压缩输出为一个更短的输出数据流.所以对于包含了调色板的 BMP 文件,由于 DIB 数组内保存的是调色板的索引号而并不是颜色值,在提交给 JPEG 库之前需要根据调色板查表构造一个真正的包含颜色信息的 DIB 像素流,这样 JPEG 库才能正常工作.

=======================================
我之前的的博客地址是 http://blog.csdn.net/querw 还有一些我以前写的文章.实在受不了他们网站的各种问题,决定改变阵地.

====================================================================================================
附录: 截取windows桌面,并保存为 .jpg 文件

  1 #include "stdafx.h"
  2 #include <tchar.h>
  3
  4 extern "C"
  5 {
  6     #include "jpeglib.h"
  7 }
  8
  9 int save_screen_to_jpeg( const char* filename, int quality)
10 {
11      /*
12     * 把屏幕内容保存为一个 HBITMAP DDB
13      */
14     HDC hScrnDC = CreateDC(_T("DISPLAY"), NULL, NULL, NULL);
15     HDC hMemDC = CreateCompatibleDC(hScrnDC);
16
17      // 获取屏幕分辨率
18      int xScrn = GetDeviceCaps(hScrnDC, HORZRES);
19      int yScrn = GetDeviceCaps(hScrnDC, VERTRES);
20
21      // 创建位图,并选中
22     HBITMAP hScrnBmp = CreateCompatibleBitmap(hScrnDC, xScrn, yScrn);
23     SelectObject(hMemDC, hScrnBmp);
24
25      // 复制屏幕内容
26     BitBlt(hMemDC, 0, 0, xScrn, yScrn, hScrnDC, 0, 0, SRCCOPY);
27
28      // 现在得到了一个 HBITMAP DDB - hScrnBmp
29
30      /*
31     * 通过 hScrnBmp DDB 取得 DIB 数据
32      */
33      // 获取色深 JPG 只能处理 24 位色,所以不管当前系统设置的色深是多少,我们都要求 GetDIBits 函数返回 24 位的 DIB 数据,同时也不需要调色板
34      // int colorDeepBits = GetDeviceCaps(hScrnBmp, BITSPIXEL);
35      // if(colorDeepBits > 24) colorDeepBits = 24;
36      int colorDeepBits = 24;
37
38      // 每行像素占用的字节数,每行要对齐4字节.
39      int imageRowSize = (xScrn * colorDeepBits + 31) / 32 * 4;
40
41      // 分配 DIB 数组
42     unsigned char* dibBuffer = new unsigned char[imageRowSize * yScrn];
43     assert(dibBuffer);
44     memset(dibBuffer, 0, imageRowSize * yScrn);     // 清零是个好习惯
45
46      // 填充 BMP 信息头
47     BITMAPINFO bmi = {0};
48     bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
49     bmi.bmiHeader.biWidth = xScrn;
50     bmi.bmiHeader.biHeight = yScrn * -1;         // JPG 压缩需要正序的 DIB 像素流,所以要负数.
51     bmi.bmiHeader.biPlanes = 1;
52     bmi.bmiHeader.biBitCount = colorDeepBits;
53     bmi.bmiHeader.biCompression = BI_RGB;
54
55      // 获取 DIB 像素数组(DIB_RGB_COLORS 表示获取 RGB 值而不是调色板索引,当然24位位图也没有调色板)
56      int gdiRet = GetDIBits(hMemDC, hScrnBmp, 0, yScrn, dibBuffer, &bmi, DIB_RGB_COLORS);
57     assert(gdiRet == yScrn);
58     assert(bmi.bmiHeader.biSizeImage == imageRowSize * yScrn);
59
60      // DIB 数据已经获取,所有的 GDI 对象可以释放了.
61     DeleteDC(hScrnDC);
62     DeleteDC(hMemDC);
63     DeleteObject(hScrnBmp);
64
65      /*
66     * 把 DIB 数据压缩为 JPG 数据,用 example.c 中的代码
67      */
68
69      // DIB 中颜色的存放顺序是 BGR, 而 JPG 要求的顺序是 RGB, 所以要交换 R 和 B.
70      // 由于有行对齐因素,所以逐行处理
71      for( int row = 0; row < yScrn; ++row)
72     {
73         unsigned char* rowData = dibBuffer + imageRowSize * row;
74          for( int col = 0; col < xScrn * 3; col += 3)
75         {
76             unsigned char swap = rowData[col];
77             rowData[col] = rowData[col + 2];
78             rowData[col + 2] = swap;
79         }
80     }
81
82      // 把位图数据压缩为 jpeg
83      struct jpeg_compress_struct cinfo;
84      struct jpeg_error_mgr jerr;
85     FILE * outfile;         /* target file */
86     JSAMPROW row_pointer[1];     /* pointer to JSAMPLE row[s] */
87      int row_stride;         /* physical row width in image buffer */
88      int image_width = xScrn;
89      int image_height = yScrn;
90     JSAMPLE* image_buffer = dibBuffer;                     // DIB buffer
91      int image_buffer_len = imageRowSize * image_height;     // DIB buffer 长度
92
93      if(fopen_s(&outfile, filename, "wb"))
94      // if ((outfile = fopen_s(filename, "wb")) == NULL)
95     {
96         fprintf(stderr, "can't open %s\n", filename);
97         assert(0);
98     }
99      else
100     {
101          /* Step 1: allocate and initialize JPEG compression object */
102         cinfo.err = jpeg_std_error(&jerr);
103
104          /* Now we can initialize the JPEG compression object. */
105         jpeg_create_compress(&cinfo);
106
107          /* Step 2: specify data destination (eg, a file) */
108          /* Note: steps 2 and 3 can be done in either order. */
109         jpeg_stdio_dest(&cinfo, outfile);
110
111          /* Step 3: set parameters for compression */
112
113          /* First we supply a description of the input image.
114          * Four fields of the cinfo struct must be filled in:
115           */
116         cinfo.image_width = image_width;      /* image width and height, in pixels */
117         cinfo.image_height = image_height;
118         cinfo.input_components = 3;         /* # of color components per pixel */ // 因为DIB数据是24位的,所以每个像素占用3个字节
119         cinfo.in_color_space = JCS_RGB;      /* colorspace of input image */
120          /* Now use the library's routine to set default compression parameters.
121          * (You must set at least cinfo.in_color_space before calling this,
122          * since the defaults depend on the source color space.)
123           */
124         jpeg_set_defaults(&cinfo);
125          /* Now you can set any non-default parameters you wish to.
126          * Here we just illustrate the use of quality (quantization table) scaling:
127           */
128         jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);
129
130          /* Step 4: Start compressor */
131
132          /* TRUE ensures that we will write a complete interchange-JPEG file.
133          * Pass TRUE unless you are very sure of what you're doing.
134           */
135         jpeg_start_compress(&cinfo, TRUE);
136
137          /* Step 5: while (scan lines remain to be written) */
138          /*            jpeg_write_scanlines(

); */
139
140          /* Here we use the library's state variable cinfo.next_scanline as the
141          * loop counter, so that we don't have to keep track ourselves.
142          * To keep things simple, we pass one scanline per call; you can pass
143          * more if you wish, though.
144           */
145         row_stride = imageRowSize;
146          while (cinfo.next_scanline < cinfo.image_height)
147         {
148              /* jpeg_write_scanlines expects an array of pointers to scanlines.
149              * Here the array is only one element long, but you could pass
150              * more than one scanline at a time if that's more convenient.
151               */
152             row_pointer[0] = &image_buffer[cinfo.next_scanline * row_stride];
153              // row_pointer[0] = &image_buffer[image_buffer_len - (cinfo.next_scanline + 1) * row_stride];
154             ( void)jpeg_write_scanlines(&cinfo, row_pointer, 1);
155         }
156
157          /* Step 6: Finish compression */
158         jpeg_finish_compress(&cinfo);
159
160          /* After finish_compress, we can close the output file. */
161         fclose(outfile);
162
163          /* Step 7: release JPEG compression object */
164          /* This is an important step since it will release a good deal of memory. */
165         jpeg_destroy_compress(&cinfo);
166     }
167
168      // 释放 DIB 数组
169     delete []dibBuffer;
170      return 0;
171 }
172

转自： http://www.cppblog.com/querw/archive/2016/05/29/213604.html