平时都用OpenCV的imwrite存图，保存为bmp格式的图片，速度快但占用空间大；存为jpg格式，占用空间小但存图时间长。
了解到libjpeg这个开源库存图，实验了一下，老版的libjpeg与OpenCV相比，没有优势。新版的libjpeg-turbo就不一样了，存图效率很高。
（1）从官网下载最新版本的libjpeg-turbo
https://libjpeg-turbo.org/
（2）安装.exe文件，解压压缩包
（3）应用
参考doc文件夹中的example.txt，了解使用步骤
注意：
要求的图片指针数据为 RGB！
要求的图片指针数据为 RGB！
要求的图片指针数据为 RGB！
参数解析：
char filename 要保存的图像文件名
int quality jpg图像的压缩率（0-100）
unsigned char image_buffer 图像指针（RGB排序）
int image_width 图像宽
int image_height 图像高
1 void write_JPEG_file(char *filename, int quality, unsigned char* image_buffer, int image_width, int image_height) 2 { 3 /* This struct contains the JPEG compression parameters and pointers to 4 * working space (which is allocated as needed by the JPEG library). 5 * It is possible to have several such structures, representing multiple 6 * compression/decompression processes, in existence at once. We refer 7 * to any one struct (and its associated working data) as a "JPEG object". 8 */
9 struct jpeg_compress_struct cinfo; 10 /* This struct represents a JPEG error handler. It is declared separately 11 * because applications often want to supply a specialized error handler 12 * (see the second half of this file for an example). But here we just 13 * take the easy way out and use the standard error handler, which will 14 * print a message on stderr and call exit() if compression fails. 15 * Note that this struct must live as long as the main JPEG parameter 16 * struct, to avoid dangling-pointer problems. 17 */
18 struct jpeg_error_mgr jerr; 19 /* More stuff */
20 FILE *outfile; /* target file */
21 JSAMPROW row_pointer[1]; /* pointer to JSAMPLE row[s] */
22 int row_stride; /* physical row width in image buffer */
23
24 /* Step 1: allocate and initialize JPEG compression object */
25
26 /* We have to set up the error handler first, in case the initialization 27 * step fails. (Unlikely, but it could happen if you are out of memory.) 28 * This routine fills in the contents of struct jerr, and returns jerr's 29 * address which we place into the link field in cinfo. 30 */
31 cinfo.err = jpeg_std_error(&jerr); 32 /* Now we can initialize the JPEG compression object. */
33 jpeg_create_compress(&cinfo); 34
35 /* Step 2: specify data destination (eg, a file) */
36 /* Note: steps 2 and 3 can be done in either order. */
37
38 /* Here we use the library-supplied code to send compressed data to a 39 * stdio stream. You can also write your own code to do something else. 40 * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that 41 * requires it in order to write binary files. 42 */
43 if ((outfile = fopen(filename, "wb")) == NULL) { 44 fprintf(stderr, "can't open %s\n", filename); 45 exit(1); 46 } 47 jpeg_stdio_dest(&cinfo, outfile); 48
49 /* Step 3: set parameters for compression */
50
51 /* First we supply a description of the input image. 52 * Four fields of the cinfo struct must be filled in: 53 */
54 cinfo.image_width = image_width; /* image width and height, in pixels */
55 cinfo.image_height = image_height; 56 cinfo.input_components = 3; /* # of color components per pixel */
57 cinfo.in_color_space = JCS_RGB; /* colorspace of input image */
58 /* Now use the library's routine to set default compression parameters. 59 * (You must set at least cinfo.in_color_space before calling this, 60 * since the defaults depend on the source color space.) 61 */
62 jpeg_set_defaults(&cinfo); 63 /* Now you can set any non-default parameters you wish to. 64 * Here we just illustrate the use of quality (quantization table) scaling: 65 */
66 jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */); 67
68 /* Step 4: Start compressor */
69
70 /* TRUE ensures that we will write a complete interchange-JPEG file. 71 * Pass TRUE unless you are very sure of what you're doing. 72 */
73 jpeg_start_compress(&cinfo, TRUE); 74
75 /* Step 5: while (scan lines remain to be written) */
76 /* jpeg_write_scanlines(...); */
77
78 /* Here we use the library's state variable cinfo.next_scanline as the 79 * loop counter, so that we don't have to keep track ourselves. 80 * To keep things simple, we pass one scanline per call; you can pass 81 * more if you wish, though. 82 */
83 row_stride = image_width * 3; /* JSAMPLEs per row in image_buffer */
84
85 while (cinfo.next_scanline < cinfo.image_height) { 86 /* jpeg_write_scanlines expects an array of pointers to scanlines. 87 * Here the array is only one element long, but you could pass 88 * more than one scanline at a time if that's more convenient. 89 */
90 row_pointer[0] = &image_buffer[cinfo.next_scanline * row_stride]; 91 (void)jpeg_write_scanlines(&cinfo, row_pointer, 1); 92 } 93
94 /* Step 6: Finish compression */
95
96 jpeg_finish_compress(&cinfo); 97 /* After finish_compress, we can close the output file. */
98 fclose(outfile); 99
100 /* Step 7: release JPEG compression object */
101
102 /* This is an important step since it will release a good deal of memory. */
103 jpeg_destroy_compress(&cinfo); 104
105 /* And we're done! */
106 }