C++通过jpeglib进行jpeg编码

#include <stdio.h>
extern "C"{
#include "../../src/jpeg_8c/jpeglib.h"
}
  
/**
brief jpeg编码，输入格式为uyvy
*/
void write_YUV_JPEG_file (char * filename,unsigned char* yuvData,int quality,int image_width,int image_height)
{
  
    struct jpeg_compress_struct cinfo;
  
    struct jpeg_error_mgr jerr;
  
    FILE * outfile; /* target file */
    //JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */
    //int row_stride; /* physical row width in image buffer */
    JSAMPIMAGE buffer;
  
    int band,i,buf_width[3],buf_height[3];
    cinfo.err = jpeg_std_error(&jerr);
  
    jpeg_create_compress(&cinfo);
  
  
    if ((outfile = fopen(filename,"wb")) == NULL) {
        fprintf(stderr,"can't open %sn",filename);
        exit(1);
    }
    jpeg_stdio_dest(&cinfo,outfile);
  
  
    cinfo.image_width = image_width; /* image width and height,in pixels */
    cinfo.image_height = image_height;
    cinfo.input_components = 3; /* # of color components per pixel */
    cinfo.in_color_space = JCS_YCbCr; /* colorspace of input image */
  
    jpeg_set_defaults(&cinfo);
  
    jpeg_set_quality(&cinfo,quality,TRUE );
  
    //////////////////////////////
    cinfo.raw_data_in = TRUE;
    cinfo.jpeg_color_space = JCS_YCbCr;
    cinfo.comp_info[0].h_samp_factor = 2;
    cinfo.comp_info[0].v_samp_factor = 1;
    /////////////////////////
  
    jpeg_start_compress(&cinfo,TRUE);
  
    buffer = (JSAMPIMAGE) (*cinfo.mem->alloc_small) ((j_common_ptr) &cinfo,JPOOL_IMAGE,3 * sizeof(JSAMPARRAY));  
    for(band=0; band<3; band++)
    {
        buf_width[band] = cinfo.comp_info[band].width_in_blocks * DCTSIZE;
        buf_height[band] = cinfo.comp_info[band].v_samp_factor * DCTSIZE;
        buffer[band] = (*cinfo.mem->alloc_sarray) ((j_common_ptr) &cinfo,buf_width[band],buf_height[band]);
    }  
  
    unsigned char *rawData[3];
    rawData[0]=yuvData;
    rawData[1]=yuvData+image_width*image_height;
    rawData[2]=yuvData+image_width*image_height*3/2;
  
    int max_line = cinfo.max_v_samp_factor*DCTSIZE;  
    for(int counter=0; cinfo.next_scanline < cinfo.image_height; counter++)
    {  
        //buffer image copy.
        for(band=0; band<3; band++)
        {
            int mem_size = buf_width[band];
            unsigned char *pDst = (unsigned char *) buffer[band][0];
            unsigned char *pSrc = (unsigned char *) (rawData[band] + //yuv.data[band]分别表示YUV起始地址
                counter*buf_height[band] * buf_width[band]);
  
            for(i=0; i<buf_height[band]; i++)
            {
                memcpy(pDst,pSrc,mem_size);
                pSrc += buf_width[band];
                pDst += buf_width[band];
            }
        }
        jpeg_write_raw_data(&cinfo,buffer,max_line);
    }
  
  
    jpeg_finish_compress(&cinfo);
  
    fclose(outfile);
  
    jpeg_destroy_compress(&cinfo);
  
  
}
  
  
/**
brief jpeg编码，输入格式为rgb
*/
void write_RGB_JPEG_file(char * filename,unsigned char *rgb,int image_height,int quality /*= 90*/)
{
    JSAMPLE * image_buffer = (JSAMPLE*)rgb;
    /* 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);
  
    /* 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(filename,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 = image_width;    /* image width and height,in pixels */
    cinfo.image_height = image_height;
    cinfo.input_components = 3;     /* # of color components per pixel */
    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,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 = image_width * 3;   /* 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] = & image_buffer[cinfo.next_scanline * row_stride];
        (void) jpeg_write_scanlines(&cinfo,row_pointer,1);
    }
  
    /* Step 6: Finish compression */
  
    jpeg_finish_compress(&cinfo);
    /* After finish_compress,we can close the output file. */
    fclose(outfile);
  
    /* Step 7: release JPEG compression object */
  
    /* This is an important step since it will release a good deal of memory. */
    jpeg_destroy_compress(&cinfo);
  
    /* And we're done! */
}
  
  
  
  
  
/**
brief jpeg编码，输入格式为yuv444
*/
void write_YUV444_JPEG_file(char * filename,unsigned char *yuv444,int quality /*= 90*/)
{
    JSAMPLE * image_buffer = (JSAMPLE*)yuv444;
    /* 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,in pixels */
    cinfo.image_height = image_height;
    cinfo.input_components = 3;     /* # of color components per pixel */
    cinfo.in_color_space = JCS_YCbCr;   /* 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,we can close the output file. */
    fclose(outfile);
  
    /* Step 7: release JPEG compression object */
  
    /* This is an important step since it will release a good deal of memory. */
    jpeg_destroy_compress(&cinfo);
  
    /* And we're done! */
}