(原)调用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[1];        /* 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 == 1)
    {
        cinfo.in_color_space = JCS_GRAYSCALE;  /* colorspace of input image */
    }
    else if (nChannel == 3)
    {
        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[0] = &inputData[cinfo.next_scanline * row_stride];
        (void)jpeg_write_scanlines(&cinfo, row_pointer, 1);
    }

    /* 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的值估计也需要修改，暂时没有考虑。