【C】libjpeg的使用方法

0xAA55

libjpeg是一个用于压缩、解压jpg格式图像的库。这个库在1998年后就不再更新了。但是jpeg的压缩格式却一直使用至今。简直是C语言中的战斗机。
libjpeg的使用方法很简单。首先借助makefile编译官方的源码取得libjpeg.lib然后设置自己的工程引用这个库就行了，我们稍后再讲怎么编译。

首先是头文件的包含。
#include"jpeglib.h"

然后就是接下来的两个部分：如何压缩，如何解压。

先说如何解压。
解压就是，你用fopen打开一个jpg文件（第二个参数是"rb"），分配内存用于存储解压后的位图，设置好你要接收的格式是什么类型，然后使用jpg的库完成解压。
首先你需要这样两个结构体：

1. struct jpeg_decompress_struct cinfo;
   
2. struct jpeg_error_mgr jem={0};

复制代码

其中jpeg_decompress_struct是装解压信息的结构体，jpeg_error_mgr是错误管理器，它里面有一系列的函数指针，你可以设置自己的错误回调函数。也可以不设置。如果你不设置，它遇到错误就执行exit(1)，直接干掉你的程序。因此这也是一种很直观的调试方式——我的程序被干掉了就说明有错。

然后就对JPG文件进行读取。

1. //打开文件
   
2. fp=fopen(szFileName,"rb");
   
3. if(!fp)
   
4.         return;
   
5. 
   
6. //设置错误处理
   
7. cinfo.err=jpeg_std_error(&jem);
   
8. 
   
9. //创建解压结构
   
10. jpeg_create_decompress(&cinfo);
    
11. 
    
12. //设置stdio读取来源
    
13. jpeg_stdio_src(&cinfo,fp);
    
14. 
    
15. //读取文件头
    
16. jpeg_read_header(&cinfo,TRUE);

复制代码

之后用户需要自己根据需求分配一下内存，用于存储位图。搞定以后，运行如下的代码。

1. //计算每行字节数的宏
   
2. #define CalcPitch(b,w) ((((b)*(w)-1)/32+1)*4)
   
3. 
   
4. //行指针
   
5. JSAMPROW row_pointer[1];
   
6. 
   
7. //每行字节数
   
8. size_t cbPitch=CalcPitch(24,宽度);
   
9. 
   
10. //设置输出的颜色类型
    
11. cinfo.out_color_space=JCS_RGB;
    
12. jpeg_calc_output_dimensions(&cinfo);
    
13. 
    
14. //开始解压
    
15. jpeg_start_decompress(&cinfo);
    
16. 
    
17. //指向自己分配好的图像内存
    
18. row_pointer[0]=(uint8_t*)g_pBits;
    
19. 
    
20. //一行一行读取
    
21. while(cinfo.output_scanline<cinfo.output_height)
    
22. {
    
23.         jpeg_read_scanlines(&cinfo,row_pointer,1);
    
24.         row_pointer[0]+=cbPitch;//转到下一行。
    
25. }
    
26. 
    
27. //读取结束
    
28. jpeg_finish_decompress(&cinfo);
    
29. 
    
30. //释放资源
    
31. jpeg_destroy_decompress(&cinfo);
    
32. 
    
33. //关闭文件
    
34. fclose(fp);

复制代码

然后你的图像就已经读取到g_pBits中了！

压缩，就是你提供一个位图（比如RGB像素阵列或者YUV阵列等，可以选择的），然后提供一个打开了写入文件的FILE*，设置好参数，就可以进行压缩了。
压缩要用到的结构体是：

1. struct jpeg_compress_struct jcs;
   
2. struct jpeg_error_mgr jem={0};

复制代码

同样的错误处理方式。
然后我们就可以打开文件进行写入操作了。

1. //打开文件进行写入
   
2. fp=fopen(szFileName,"wb");
   
3. if(!fp)
   
4.         return;
   
5. 
   
6. //设置错误处理
   
7. jcs.err=jpeg_std_error(&jem);
   
8. 
   
9. //创建压缩结构
   
10. jpeg_create_compress(&jcs);
    
11. 
    
12. //设置stdio写入位置
    
13. jpeg_stdio_dest(&jcs,fp);
    
14. 
    
15. //设置写入参数
    
16. jcs.image_width=宽度;//为图的宽和高，单位为像素
    
17. jcs.image_height=高度;
    
18. jcs.input_components=3;//图像源有红绿蓝三个组分
    
19. jcs.in_color_space=JCS_RGB;//格式是红绿蓝真彩色
    
20. jpeg_set_defaults(&jcs);//填写其它默认数值
    
21. 
    
22. //设置图像品质
    
23. //值的取值范围是[0,100]，0表示渣画质，100表示满画质。
    
24. jpeg_set_quality(&jcs,0/*渣画质*/,TRUE);
    
25. 
    
26. //计算每行字节数
    
27. cbPitch=CalcPitch(24,宽度);
    
28. 
    
29. //开始压缩
    
30. jpeg_start_compress(&jcs,TRUE);
    
31. 
    
32. //指向要存储的位图。
    
33. row_pointer[0]=(uint8_t*)g_pBits;
    
34. 
    
35. //一行一行写入
    
36. while(jcs.next_scanline<jcs.image_height)
    
37. {
    
38.         jpeg_write_scanlines(&jcs,row_pointer,1);
    
39.         row_pointer[0]+=cbPitch;//转到下一行
    
40. }
    
41. 
    
42. //读取结束
    
43. jpeg_finish_compress(&jcs);
    
44. 
    
45. //释放资源
    
46. jpeg_destroy_compress(&jcs);
    
47. 
    
48. //关闭文件
    
49. fclose(fp);

复制代码

接下来就是完整的工程的代码了。
这个工程演示了如何读取jpg、写入jpg的方法。
它会加载工程文件夹中的test.jpg，然后以渣画质方式输出到out.jpg。最后创建一个窗口用于显示加载的jpg图像。
（PS.为什么要用渣画质输出？因为这样能明显看到它有效地设置了画质然后输出了文件。）

1. #include<tchar.h>
   
2. #include<stdio.h>
   
3. #include<Windows.h>
   
4. 
   
5. #include<memory.h>
   
6. #include<stdint.h>
   
7. 
   
8. #undef FAR
   
9. #define XMD_H
   
10. #include"jpeglib.h"
    
11. 
    
12. uint32_t        g_uWidth;
    
13. uint32_t        g_uHeight;
    
14. void                *g_pBits=NULL;
    
15. HDC                        g_hDCJpeg=NULL;
    
16. HBITMAP                g_hBMPJpeg=NULL;
    
17. 
    
18. #define CalcPitch(b,w) ((((b)*(w)-1)/32+1)*4)
    
19. 
    
20. //=============================================================================
    
21. //函数：BuildBitmap
    
22. //描述：建立位图用于绘图
    
23. //-----------------------------------------------------------------------------
    
24. void BuildBitmap(uint32_t uWidth,uint32_t uHeight)
    
25. {
    
26.         BITMAPINFOHEADER BMIF=
    
27.         {
    
28.                 sizeof(BITMAPINFOHEADER),
    
29.                 (LONG)uWidth,
    
30.                 -(LONG)uHeight,
    
31.                 1,
    
32.                 24,
    
33.                 BI_RGB,
    
34.                 0,
    
35.                 0,
    
36.                 0,
    
37.                 0,
    
38.                 0
    
39.         };
    
40.         g_uWidth=uWidth;
    
41.         g_uHeight=uHeight;
    
42.         if(g_hBMPJpeg)
    
43.                 DeleteObject(&g_hBMPJpeg);
    
44.         if(g_hDCJpeg)
    
45.                 DeleteDC(g_hDCJpeg);
    
46.         g_hDCJpeg=CreateCompatibleDC(NULL);
    
47.         if(!g_hDCJpeg)
    
48.                 return;
    
49.         g_hBMPJpeg=CreateDIBSection(g_hDCJpeg,(BITMAPINFO*)&BMIF,DIB_PAL_COLORS,&g_pBits,NULL,0);
    
50.         if(!g_hBMPJpeg)
    
51.                 return;
    
52.         SelectObject(g_hDCJpeg,g_hBMPJpeg);
    
53. }
    
54. 
    
55. //=============================================================================
    
56. //函数：LoadJPG
    
57. //描述：从文件中加载
    
58. //-----------------------------------------------------------------------------
    
59. void LoadJPG(char*szFileName)
    
60. {
    
61.         struct jpeg_decompress_struct cinfo;
    
62.         struct jpeg_error_mgr jem={0};
    
63.         FILE*fp=NULL;
    
64.         JSAMPROW row_pointer[1];
    
65.         size_t cbPitch;
    
66. 
    
67.         fp=fopen(szFileName,"rb");
    
68.         if(!fp)
    
69.                 return;
    
70. 
    
71.         //设置错误处理
    
72.         cinfo.err=jpeg_std_error(&jem);
    
73. 
    
74.         //创建解压结构
    
75.         jpeg_create_decompress(&cinfo);
    
76. 
    
77.         //设置stdio读取来源
    
78.         jpeg_stdio_src(&cinfo,fp);
    
79. 
    
80.         //读取文件头
    
81.         jpeg_read_header(&cinfo,TRUE);
    
82. 
    
83.         //分配内存，构建位图
    
84.         BuildBitmap(cinfo.image_width,cinfo.image_height);
    
85.         cbPitch=CalcPitch(24,g_uWidth);
    
86. 
    
87.         //设置输出的颜色类型
    
88.         cinfo.out_color_space=JCS_RGB;
    
89.         jpeg_calc_output_dimensions(&cinfo);
    
90. 
    
91.         //开始解压
    
92.         jpeg_start_decompress(&cinfo);
    
93. 
    
94.         row_pointer[0]=(uint8_t*)g_pBits;
    
95. 
    
96.         //一行一行读取
    
97.         while(cinfo.output_scanline<cinfo.output_height)
    
98.         {
    
99.                 jpeg_read_scanlines(&cinfo,row_pointer,1);
    
100.                 row_pointer[0]+=cbPitch;
     
101.         }
     
102. 
     
103.         //读取结束
     
104.         jpeg_finish_decompress(&cinfo);
     
105. 
     
106.         //释放资源
     
107.         jpeg_destroy_decompress(&cinfo);
     
108. 
     
109.         //关闭文件
     
110.         fclose(fp);
     
111. }
     
112. 
     
113. //=============================================================================
     
114. //函数：SaveJPG
     
115. //描述：保存到文件
     
116. //-----------------------------------------------------------------------------
     
117. void SaveJPG(char*szFileName)
     
118. {
     
119.         struct jpeg_compress_struct jcs;
     
120.         struct jpeg_error_mgr jem={0};
     
121.         FILE*fp=NULL;
     
122.         JSAMPROW row_pointer[1];
     
123.         size_t cbPitch;
     
124. 
     
125.         //打开文件进行写入
     
126.         fp=fopen(szFileName,"wb");
     
127.         if(!fp)
     
128.                 return;
     
129. 
     
130.         //设置错误处理
     
131.         jcs.err=jpeg_std_error(&jem);
     
132. 
     
133.         //创建压缩结构
     
134.         jpeg_create_compress(&jcs);
     
135. 
     
136.         //设置stdio写入位置
     
137.         jpeg_stdio_dest(&jcs,fp);
     
138. 
     
139.         //设置写入参数
     
140.         jcs.image_width=g_uWidth;//为图的宽和高，单位为像素
     
141.         jcs.image_height=g_uHeight;
     
142.         jcs.input_components=3;//图像源有红绿蓝三个组分
     
143.         jcs.in_color_space=JCS_RGB;//格式是红绿蓝真彩色
     
144.         jpeg_set_defaults(&jcs);
     
145. 
     
146.         //设置图像品质
     
147.         jpeg_set_quality(&jcs,0/*渣画质*/,TRUE);
     
148. 
     
149.         cbPitch=CalcPitch(24,g_uWidth);
     
150. 
     
151.         //开始压缩
     
152.         jpeg_start_compress(&jcs,TRUE);
     
153. 
     
154.         row_pointer[0]=(uint8_t*)g_pBits;
     
155. 
     
156.         //一行一行写入
     
157.         while(jcs.next_scanline<jcs.image_height)
     
158.         {
     
159.                 jpeg_write_scanlines(&jcs,row_pointer,1);
     
160.                 row_pointer[0]+=cbPitch;
     
161.         }
     
162. 
     
163.         //读取结束
     
164.         jpeg_finish_compress(&jcs);
     
165. 
     
166.         //释放资源
     
167.         jpeg_destroy_compress(&jcs);
     
168. 
     
169.         //关闭文件
     
170.         fclose(fp);
     
171. }
     
172. 
     
173. //=============================================================================
     
174. //函数：SwapRGB
     
175. //描述：将颜色从BGR到RGB之间进行转换
     
176. //-----------------------------------------------------------------------------
     
177. void SwapRGB()
     
178. {
     
179.         uint8_t*pLinePtr;
     
180.         uint32_t x,y;
     
181.         size_t cbPitch;
     
182.         pLinePtr=(uint8_t*)g_pBits;
     
183.         cbPitch=CalcPitch(24,g_uWidth);
     
184.         for(y=0;y<g_uHeight;y++)
     
185.         {
     
186.                 for(x=0;x<g_uWidth;x++)
     
187.                 {
     
188.                         uint8_t t=pLinePtr[x*3];
     
189.                         pLinePtr[x*3]=pLinePtr[x*3+2];
     
190.                         pLinePtr[x*3+2]=t;
     
191.                 }
     
192.                 pLinePtr+=cbPitch;
     
193.         }
     
194. }
     
195. 
     
196. LRESULT CALLBACK WndProc(HWND hWnd,UINT Msg,WPARAM wp,LPARAM lp);
     
197. 
     
198. int APIENTRY _tWinMain
     
199. (
     
200.         HINSTANCE hInst,
     
201.         HINSTANCE hPrevInst,
     
202.         LPTSTR lpCmdLine,
     
203.         int nShow
     
204. )
     
205. {
     
206.         MSG msg;
     
207. 
     
208.         WNDCLASSEX WCEx=
     
209.         {
     
210.                 sizeof(WNDCLASSEX),
     
211.                 0,
     
212.                 WndProc,
     
213.                 0,
     
214.                 0,
     
215.                 hInst,
     
216.                 LoadIcon(NULL,MAKEINTRESOURCE(IDI_APPLICATION)),
     
217.                 LoadCursor(NULL,MAKEINTRESOURCE(IDC_ARROW)),
     
218.                 (HBRUSH)(COLOR_BTNFACE+1),
     
219.                 NULL,
     
220.                 TEXT("Jpeg_Demo_Window"),
     
221.                 LoadIcon(NULL,MAKEINTRESOURCE(IDI_APPLICATION))
     
222.         };
     
223. 
     
224.         HWND hWnd=CreateWindowEx(0,MAKEINTATOM(RegisterClassEx(&WCEx)),TEXT("JPG"),
     
225.                 WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,
     
226.                 CW_USEDEFAULT,CW_USEDEFAULT,
     
227.                 NULL,NULL,hInst,NULL);
     
228. 
     
229.         ShowWindow(hWnd,nShow);
     
230.         UpdateWindow(hWnd);
     
231. 
     
232.         while(GetMessage(&msg,NULL,0,0))
     
233.         {
     
234.                 TranslateMessage(&msg);
     
235.                 DispatchMessage(&msg);
     
236.         }
     
237.         return msg.wParam;
     
238. }
     
239. 
     
240. LRESULT CALLBACK WndProc(HWND hWnd,UINT Msg,WPARAM wp,LPARAM lp)
     
241. {
     
242.         switch(Msg)
     
243.         {
     
244.         case WM_CREATE:
     
245.                 LoadJPG("test.jpg");
     
246.                 SaveJPG("out.jpg");
     
247.                 SwapRGB();
     
248.                 break;
     
249.         case WM_PAINT:
     
250.                 {
     
251.                         RECT rc;
     
252.                         PAINTSTRUCT ps;
     
253.                         HDC hDC=BeginPaint(hWnd,&ps);
     
254.                         uint32_t TargW,TargH;
     
255. 
     
256.                         SetStretchBltMode(hDC,HALFTONE);
     
257. 
     
258.                         GetClientRect(hWnd,&rc);
     
259.                         TargW=rc.right-rc.left;
     
260.                         TargH=rc.bottom-rc.top;
     
261. 
     
262.                         //如果需要缩小
     
263.                         if(TargW<g_uWidth||TargH<g_uHeight)
     
264.                         {
     
265.                                 uint32_t DstW,DstH;
     
266.                                 //首先宽度固定，计算高度
     
267.                                 DstW=TargW;
     
268.                                 DstH=DstW*g_uHeight/g_uWidth;
     
269.                                 //如果高度超过目标，则高度固定，计算宽度
     
270.                                 if(DstH>TargH)
     
271.                                 {
     
272.                                         DstH=TargH;
     
273.                                         DstW=DstH*g_uWidth/g_uHeight;
     
274.                                 }
     
275.                                 StretchBlt(hDC,rc.left,rc.top,DstW,DstH,g_hDCJpeg,0,0,g_uWidth,g_uHeight,SRCCOPY);
     
276.                         }
     
277.                         else
     
278.                                 BitBlt(hDC,rc.left,rc.top,g_uWidth,g_uHeight,g_hDCJpeg,0,0,SRCCOPY);
     
279.                         EndPaint(hWnd,&ps);
     
280.                 }
     
281.                 break;
     
282.         case WM_SIZING:
     
283.         case WM_SIZE:
     
284.                 {
     
285.                         RECT rc;
     
286.                         GetClientRect(hWnd,&rc);
     
287.                         InvalidateRect(hWnd,&rc,TRUE);
     
288.                 }
     
289.                 break;
     
290.         case WM_DESTROY:
     
291.                 if(g_hBMPJpeg)
     
292.                         DeleteObject(&g_hBMPJpeg);
     
293.                 if(g_hDCJpeg)
     
294.                         DeleteDC(g_hDCJpeg);
     
295.                 PostQuitMessage(0);
     
296.                 break;
     
297.         }
     
298.         return DefWindowProc(hWnd,Msg,wp,lp);
     
299. }

复制代码

原图：

图像来源：http://www.pixiv.net/member_illu ... ;illust_id=48042573
作者：稀泥m
途中的角色：時崎 狂三

程序窗口图：

BIN: jpeg.exe (114.09 KB, 下载次数: 9)

2015-4-8 17:40 上传

点击文件名下载附件

SRC: jpeg.7z (255.78 KB, 下载次数: 28)

2015-4-8 17:41 上传

点击文件名下载附件

接下来说到另一个问题——怎么取得libjpeg.lib？其实我觉得你既然能得到官方的源码了你就能自己编译。你可以用makefile编译，也可以自己建立一个工程来编译。那就像我上传的源码那样，直接把libjpeg中的源码加入到工程中参与编译就行了。
你只需要将以下的这些文件加入到自己的工程中，然后编译为静态库就行了。这样你还能借助VS的IDE设置自己的优化方式呢。
jcapimin.c,jcapistd.c,jccoefct.c,jccolor.c,jcdctmgr.c,jchuff.c,jchuff.h,jcinit.c,jcmainct.c,jcmarker.c,jcmaster.c,jcomapi.c,jconfig.h,jcparam.c,jcphuff.c,jcprepct.c,jcsample.c,jctrans.c,jdapimin.c,jdapistd.c,jdatadst.c,jdatasrc.c,jdcoefct.c,jdcolor.c,jdct.h,jddctmgr.c,jdhuff.c,jdhuff.h,jdinput.c,jdmainct.c,jdmarker.c,jdmaster.c,jdmerge.c,jdphuff.c,jdpostct.c,jdsample.c,jdtrans.c,jerror.c,jerror.h,jfdctflt.c,jfdctfst.c,jfdctint.c,jidctflt.c,jidctfst.c,jidctint.c,jidctred.c,jinclude.h,jmemmgr.c,jmemnobs.c,jmemsys.h,jmorecfg.h,jpegint.h,jpeglib.h,jquant1.c,jquant2.c,jutils.c,jversion.h然后你自己的工程只需要包含jpeglib.h就行了。其中jconfig.h是我从ijg的开源库中jconfig.vs改过来的。内存管理的源码用的是jmemnobs.c。对于Mac OS X遗迹其它系统，应该使用其它的内存管理源码。