(原)调用jpeglib对图像进行压缩

网址：http://www.cnblogs.com/darkknightzh/p/4973828.html。未经允许，严禁转载。

参考网站：

http://dev.w3.org/Amaya/libjpeg/example.c

http://www.360doc.com/content/13/0226/15/2036337_268016821.shtml

1. 首先去官网http://www.ijg.org/files/下载源码，下载的是jpegsr9a.zip。

2. 解压后放到E盘根目录，“E:\jpeg-9a\”下会有很多文件。

3. 将“jconfig.vc”改成“jconfig.h”

4. 将“makefile.vc”中第12行

!include <win32.mak>

改成

!include <C:\Program Files\Microsoft SDKs\Windows\v6.0A\Include\win32.mak>

5. 打开vs2013的“VS2013 开发人员命令提示”

6. 定位到E:\jpeg-9a。在命令行中输入：

E:

之后输入：

cd jpeg-9a

7. 输入” nmake -f makefile.vc” 生成所需要的libjpeg.lib函数库。

8. 使用时，将“jconfig.h”、“jmorecfg.h”、“jpeglib.h”、“libjpeg.lib”四个文件拷贝到对应的文件夹内。

9.  libjpeg.lib是用c语言开发的，
    如果在C++程序里使用，需要用extern "C" { }包含一下。如下：

extern "C"
{
#include "jpeglib.h"
}

10. 在“解决方案资源管理器”中“属性页“的”连接器-输入-附加依赖项”内，增加“libjpeg.lib”

11. 从缓冲区生成jpg的程序：

 void GeneJpegFile(const char* jpegFileName, unsigned char* inputData,
     int nWidth, int nHeight, int nChannel, int nQuality)
 {
     /* This struct contains the JPEG compression parameters and pointers to
     * working space (which is allocated as needed by the JPEG library).
     * It is possible to have several such structures, representing multiple
     * compression/decompression processes, in existence at once.  We refer
     * to any one struct (and its associated working data) as a "JPEG object".
     */
     struct jpeg_compress_struct cinfo;

     /* This struct represents a JPEG error handler.  It is declared separately
     * because applications often want to supply a specialized error handler
     * (see the second half of this file for an example).  But here we just
     * take the easy way out and use the standard error handler, which will
     * print a message on stderr and call exit() if compression fails.
     * Note that this struct must live as long as the main JPEG parameter
     * struct, to avoid dangling-pointer problems.
     */
     struct jpeg_error_mgr jerr;

     /* More stuff */
     FILE *outfile;                  /* target file */
     JSAMPROW row_pointer[];        /* pointer to JSAMPLE row[s] */
     int     row_stride;             /* physical row width in image buffer */

     /* Step 1: allocate and initialize JPEG compression object */

     /* We have to set up the error handler first, in case the initialization
     * step fails.  (Unlikely, but it could happen if you are out of memory.)
     * This routine fills in the contents of struct jerr, and returns jerr's
     * address which we place into the link field in cinfo.
     */
     cinfo.err = jpeg_std_error(&jerr);

     /* Now we can initialize the JPEG compression object. */
     jpeg_create_compress(&cinfo);  /* Now we can initialize the JPEG compression object. */

     /* Step 2: specify data destination (eg, a file) */
     /* Note: steps 2 and 3 can be done in either order. */

     /* Here we use the library-supplied code to send compressed data to a
     * stdio stream.  You can also write your own code to do something else.
     * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
     * requires it in order to write binary files.
     */
     if ((outfile = fopen(jpegFileName, "wb")) == NULL)
     {
         fprintf(stderr, "can't open %s\n", jpegFileName);
         return;
     }
     jpeg_stdio_dest(&cinfo, outfile);

     /* Step 3: set parameters for compression */

     /* First we supply a description of the input image.
     * Four fields of the cinfo struct must be filled in:
     */
     cinfo.image_width = nWidth;                /* image width and height, in pixels */
     cinfo.image_height = nHeight;
     cinfo.input_components = nChannel;         /* # of color components per pixel */

     if (nChannel == )
     {
         cinfo.in_color_space = JCS_GRAYSCALE;  /* colorspace of input image */
     }
     else if (nChannel == )
     {
         cinfo.in_color_space = JCS_RGB;        /* colorspace of input image */
     }

     /* Now use the library's routine to set default compression parameters.
     * (You must set at least cinfo.in_color_space before calling this,
     * since the defaults depend on the source color space.)
     */
     jpeg_set_defaults(&cinfo);

     // Now you can set any non-default parameters you wish to.
     // Here we just illustrate the use of quality (quantization table) scaling:
     jpeg_set_quality(&cinfo, nQuality, TRUE); /* limit to baseline-JPEG values */

     /* Step 4: Start compressor */

     /* TRUE ensures that we will write a complete interchange-JPEG file.
     * Pass TRUE unless you are very sure of what you're doing.
     */
     jpeg_start_compress(&cinfo, TRUE);

     /* Step 5: while (scan lines remain to be written) */
     /*           jpeg_write_scanlines(...); */

     /* Here we use the library's state variable cinfo.next_scanline as the
     * loop counter, so that we don't have to keep track ourselves.
     * To keep things simple, we pass one scanline per call; you can pass
     * more if you wish, though.
     */
     row_stride = nWidth * nChannel; /* JSAMPLEs per row in image_buffer */

     while (cinfo.next_scanline < cinfo.image_height)
     {
         /* jpeg_write_scanlines expects an array of pointers to scanlines.
         * Here the array is only one element long, but you could pass
         * more than one scanline at a time if that's more convenient.
         */
         row_pointer[] = &inputData[cinfo.next_scanline * row_stride];
         (void)jpeg_write_scanlines(&cinfo, row_pointer, );
     }

     /* Step 6: Finish compression */
     jpeg_finish_compress(&cinfo);
     jpeg_destroy_compress(&cinfo);

     /* After finish_compress, we can close the output file. */
     fclose(outfile);
 }

说明：

1. 灰度图像的话，缓冲区大小就是width*height.

2. RGB图像的话，缓冲区大小是width*height*3，同时，像素排列顺序是RGB RGB RGB RGB…

3. 其他格式的话，cinfo.in_color_space需要改成相应的格式，且row_stride的值估计也需要修改，暂时没有考虑。