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

!include <win32.mak>

!include <C:Program FilesMicrosoft SDKsWindowsv6.0AIncludewin32.mak>

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

  1 void GeneJpegFile(const char* jpegFileName, unsigned char* inputData,
  2     int nWidth, int nHeight, int nChannel, int nQuality)
  3 {
  4     /* This struct contains the JPEG compression parameters and pointers to
  5     * working space (which is allocated as needed by the JPEG library).
  6     * It is possible to have several such structures, representing multiple
  7     * compression/decompression processes, in existence at once.  We refer
  8     * to any one struct (and its associated working data) as a "JPEG object".
  9     */
 10     struct jpeg_compress_struct cinfo;
 11 
 12     /* This struct represents a JPEG error handler.  It is declared separately
 13     * because applications often want to supply a specialized error handler
 14     * (see the second half of this file for an example).  But here we just
 15     * take the easy way out and use the standard error handler, which will
 16     * print a message on stderr and call exit() if compression fails.
 17     * Note that this struct must live as long as the main JPEG parameter
 18     * struct, to avoid dangling-pointer problems.
 19     */
 20     struct jpeg_error_mgr jerr;
 21 
 22     /* More stuff */
 23     FILE *outfile;                  /* target file */
 24     JSAMPROW row_pointer[1];        /* pointer to JSAMPLE row[s] */
 25     int     row_stride;             /* physical row width in image buffer */
 26 
 27     /* Step 1: allocate and initialize JPEG compression object */
 28 
 29     /* We have to set up the error handler first, in case the initialization
 30     * step fails.  (Unlikely, but it could happen if you are out of memory.)
 31     * This routine fills in the contents of struct jerr, and returns jerr's
 32     * address which we place into the link field in cinfo.
 33     */
 34     cinfo.err = jpeg_std_error(&jerr);
 35 
 36     /* Now we can initialize the JPEG compression object. */
 37     jpeg_create_compress(&cinfo);  /* Now we can initialize the JPEG compression object. */
 38 
 39     /* Step 2: specify data destination (eg, a file) */
 40     /* Note: steps 2 and 3 can be done in either order. */
 41 
 42     /* Here we use the library-supplied code to send compressed data to a
 43     * stdio stream.  You can also write your own code to do something else.
 44     * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
 45     * requires it in order to write binary files.
 46     */
 47     if ((outfile = fopen(jpegFileName, "wb")) == NULL)
 48     {
 49         fprintf(stderr, "can't open %s
", jpegFileName);
 50         return;
 51     }
 52     jpeg_stdio_dest(&cinfo, outfile);
 53 
 54     /* Step 3: set parameters for compression */
 55 
 56     /* First we supply a description of the input image.
 57     * Four fields of the cinfo struct must be filled in:
 58     */
 59     cinfo.image_width = nWidth;                /* image width and height, in pixels */
 60     cinfo.image_height = nHeight;
 61     cinfo.input_components = nChannel;         /* # of color components per pixel */
 62 
 63     if (nChannel == 1)
 64     {
 65         cinfo.in_color_space = JCS_GRAYSCALE;  /* colorspace of input image */
 66     }
 67     else if (nChannel == 3)
 68     {
 69         cinfo.in_color_space = JCS_RGB;        /* colorspace of input image */
 70     }
 71     
 72     /* Now use the library's routine to set default compression parameters.
 73     * (You must set at least cinfo.in_color_space before calling this,
 74     * since the defaults depend on the source color space.)
 75     */
 76     jpeg_set_defaults(&cinfo);
 77 
 78     // Now you can set any non-default parameters you wish to.
 79     // Here we just illustrate the use of quality (quantization table) scaling:
 80     jpeg_set_quality(&cinfo, nQuality, TRUE); /* limit to baseline-JPEG values */
 81 
 82     /* Step 4: Start compressor */
 83 
 84     /* TRUE ensures that we will write a complete interchange-JPEG file.
 85     * Pass TRUE unless you are very sure of what you're doing.
 86     */
 87     jpeg_start_compress(&cinfo, TRUE);
 88 
 89     /* Step 5: while (scan lines remain to be written) */
 90     /*           jpeg_write_scanlines(...); */
 91 
 92     /* Here we use the library's state variable cinfo.next_scanline as the
 93     * loop counter, so that we don't have to keep track ourselves.
 94     * To keep things simple, we pass one scanline per call; you can pass
 95     * more if you wish, though.
 96     */
 97     row_stride = nWidth * nChannel; /* JSAMPLEs per row in image_buffer */
 98 
 99     while (cinfo.next_scanline < cinfo.image_height)
100     {
101         /* jpeg_write_scanlines expects an array of pointers to scanlines.
102         * Here the array is only one element long, but you could pass
103         * more than one scanline at a time if that's more convenient.
104         */
105         row_pointer[0] = &inputData[cinfo.next_scanline * row_stride];
106         (void)jpeg_write_scanlines(&cinfo, row_pointer, 1);
107     }
108 
109     /* Step 6: Finish compression */
110     jpeg_finish_compress(&cinfo);
111     jpeg_destroy_compress(&cinfo);
112 
113     /* After finish_compress, we can close the output file. */
114     fclose(outfile);
115 }