android 使用libjpeg-turbo将yuv2jpeg图像
要将yuv2jpeg图像则需要两个准备，一、准备libjpeg-turbo库，可以查看之前android 编译libjpeg-turbo文章，二、调用libjpeg-turbo代码，可以查看源码中的Exception.c文件，也可以看之前的使用libjpeg对图像进行压缩文章，下面就是根据这两篇文章来编写调用libjpeg-turbo库来实现yuv2jpeg的功能。
1、将h264解码成yuv我是通过ffmpeg来实现的，解码生成的yuv存放在frame->data[0],frame->data[1],frame->data[2],而代码中的yuv三个分量还需要将之前的三个分量进行转换才行，代码如下，其中y，u，v这三个分量就是之后代码中需要的三个参数：
int j = 0,i = 0;//抽取YUV数据
for (i = 0; i < VIDEO_HEIGHT; i++) {
memcpy(&(y[VIDEO_WIDTH*i]), &frame->data[0][frame->linesize[0]*i], VIDEO_WIDTH);
if (i % 2== 0) {
memcpy(&(u[(HALF_VIDEO_WIDTH)*j]), &frame->data[1][frame->linesize[1]*j], HALF_VIDEO_WIDTH);
memcpy(&(v[(HALF_VIDEO_WIDTH)*j]), &frame->data[2][frame->linesize[2]*j], HALF_VIDEO_WIDTH);
j++;
}
}
2、调用libjpeg-turbo库的代码如下，我这里写在一个叫yuv2jpg.c文件中，yuv2jpg.h里面写对write_JPEG_file函数的声明：
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include "yuv2jpg.h"
#include <android/log.h>
#include "jpeglib.h"
#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "native-activity", __VA_ARGS__))
#define LOG(...) ((void)__android_log_print(ANDROID_LOG_WARN, "native-activity", __VA_ARGS__))
int write_JPEG_file(const char *filename, unsigned char* yData, unsigned char* uData, unsigned char* vData, int quality,int image_width,int image_height)
{
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
FILE * outfile; // target file
JSAMPIMAGE buffer;
unsigned char *pSrc,*pDst;
int band,i,buf_width[3],buf_height[3];
cinfo.err = jpeg_std_error(&jerr);
// LOG("1 %s", filename);
jpeg_create_compress(&cinfo); \
// LOG("2");
if ((outfile = fopen(filename, "wb")) == NULL) {
// LOG("NULL");
return -1;
}
// LOG("3");
jpeg_stdio_dest(&cinfo, outfile);
// LOG("4");
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
// LOG("5");
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 = 2;
/////////////////////////
// LOG("6");
jpeg_start_compress(&cinfo, TRUE);
// LOG("7");
buffer = (JSAMPIMAGE) (*cinfo.mem->alloc_small) ((j_common_ptr) &cinfo,
JPOOL_IMAGE, 3 * sizeof(JSAMPARRAY));
// LOG("8");
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,
JPOOL_IMAGE, buf_width[band], buf_height[band]);
}
// LOG("9");
unsigned char *rawData[3];
rawData[0]= yData; rawData[1] = uData; rawData[2] = vData;
int src_width[3],src_height[3];
for(i=0;i<3;i++)
{
src_width[i]=(i==0)?image_width:image_width/2;
src_height[i]=(i==0)?image_height:image_height/2;
}
// LOG("10");
//max_line一般为16，外循环每次处理16行数据。
int max_line = cinfo.max_v_samp_factor*DCTSIZE;
int counter;
for(counter=0; cinfo.next_scanline < cinfo.image_height; counter++)
{
//buffer image copy.
for(band=0; band <3; band++) //每个分量分别处理
{
int mem_size = src_width[band];//buf_width[band];
pDst = (unsigned char *) buffer[band][0];
pSrc = (unsigned char *) rawData[band] + counter*buf_height[band] * src_width[band];//buf_width[band]; //yuv.data[band]分别表示YUV起始地址
for(i=0; i <buf_height[band]; i++) //处理每行数据
{
memcpy(pDst, pSrc, mem_size);
pSrc += src_width[band];//buf_width[band];
pDst += buf_width[band];
}
}
// LOG("11");
jpeg_write_raw_data(&cinfo, buffer, max_line);
}
jpeg_finish_compress(&cinfo);
// LOG("12");
fclose(outfile);
jpeg_destroy_compress(&cinfo);
// LOG("13");
return 0;
}
3、将上面的代码放在一个c文件里面然后放在源码里面，目录如下root@zhangjie:/home/libjpeg-turbo/jni#
root@zhangjie:/home/libjpeg-turbo-1.2.1/jni# ls acinclude.m4 compile install.txt jconfig.h jdcolext.c jerror.h jpegtran.c pkgscripts structure.txt usage.txt aclocal.m4 config.guess jaricom.c jconfig.h.in jdcolor.c jfdctflt.c jquant1.c rdbmp.c testimages win Android.mk config.h java jconfig.txt jdct.h jfdctfst.c jquant2.c rdcolmap.c tjbench.c wizard.txt Android.mk~ config.h.in jcapimin.c jcparam.c jddctmgr.c jfdctint.c jsimddct.h rdgif.c tjbenchtest wrbmp.c bmp.c config.log jcapistd.c jcphuff.c jdhuff.c jidctflt.c jsimd.h rdjpgcom.1 tjbenchtest.in wrgif.c bmp.h config.status jcarith.c jcprepct.c jdhuff.h jidctfst.c jsimd_none.c rdjpgcom.c tjexampletest wrjpgcom.1 BUILDING.txt config.sub jccoefct.c jcsample.c jdinput.c jidctint.c jutils.c rdppm.c tjexampletest.in wrjpgcom.c cderror.h configure jccolext.c jcstest.c jdmainct.c jidctred.c jversion.h rdrle.c tjunittest.c wrppm.c cdjpeg.c configure.ac jccolor.c jctrans.c jdmarker.c jinclude.h libjpeg.map rdswitch.c tjutil.c wrrle.c cdjpeg.h depcomp jcdctmgr.c jdapimin.c jdmaster.c jmemmgr.c libjpeg.map.in rdtarga.c tjutil.h wrtarga.c change.log djpeg.1 jchuff.c jdapistd.c jdmerge.c jmemnobs.c libjpeg.txt README transupp.c yuv2jpg.c ChangeLog.txt djpeg.c jchuff.h jdarith.c jdmrgext.c jmemsys.h libtool README-turbo.txt transupp.h yuv2jpg.h cjpeg.1 doc jcinit.c jdatadst.c jdphuff.c jmorecfg.h ltmain.sh release turbojpeg.c cjpeg.c doxygen.config jcmainct.c jdatadst-tj.c jdpostct.c jpegcomp.h Makefile sharedlib turbojpeg.h CMakeLists.txt example.c jcmarker.c jdatasrc.c jdsample.c jpegint.h Makefile.am simd turbojpeg-jni.c cmakescripts filelist.txt jcmaster.c jdatasrc-tj.c jdtrans.c jpeglib.h Makefile.in stamp-h1 turbojpeg-mapfile coderules.txt install-sh jcomapi.c jdcoefct.c jerror.c jpegtran.1 missing stamp-h2 turbojpeg-mapfile.jni
4、在之前的编译libjpeg-turbo的Android.mk中，添加刚才编写的.c文件，如下：
# Makefile for libjpeg-turbo
##################################################
### simd ###
##################################################
LOCAL_PATH := $(my-dir)
include $(CLEAR_VARS)
LOCAL_CFLAGS += -D__ARM_HAVE_NEON
# From autoconf-generated Makefile
EXTRA_DIST = simd/nasm_lt.sh simd/jcclrmmx.asm simd/jcclrss2.asm simd/jdclrmmx.asm simd/jdclrss2.asm \
simd/jdmrgmmx.asm simd/jdmrgss2.asm simd/jcclrss2-64.asm simd/jdclrss2-64.asm \
simd/jdmrgss2-64.asm simd/CMakeLists.txt
libsimd_SOURCES_DIST = simd/jsimd_arm_neon.S \
simd/jsimd_arm.c
LOCAL_SRC_FILES := $(libsimd_SOURCES_DIST)
LOCAL_C_INCLUDES := $(LOCAL_PATH)/simd \
$(LOCAL_PATH)/android
AM_CFLAGS := -march=armv7-a -mfpu=neon
AM_CCASFLAGS := -march=armv7-a -mfpu=neon
LOCAL_ARM_MODE=arm
LOCAL_MODULE_TAGS := debug
LOCAL_MODULE := libsimd
include $(BUILD_STATIC_LIBRARY)
######################################################
### libjpeg.so ##
######################################################
include $(CLEAR_VARS)
# From autoconf-generated Makefile
libjpeg_SOURCES_DIST = yuv2jpg.c jcapimin.c jcapistd.c jccoefct.c jccolor.c \
jcdctmgr.c jchuff.c jcinit.c jcmainct.c jcmarker.c jcmaster.c \
jcomapi.c jcparam.c jcphuff.c jcprepct.c jcsample.c jctrans.c \
jdapimin.c jdapistd.c jdatadst.c jdatasrc.c jdcoefct.c jdcolor.c \
jddctmgr.c jdhuff.c jdinput.c jdmainct.c jdmarker.c jdmaster.c \
jdmerge.c jdphuff.c jdpostct.c jdsample.c jdtrans.c jerror.c \
jfdctflt.c jfdctfst.c jfdctint.c jidctflt.c jidctfst.c jidctint.c \
jidctred.c jquant1.c jquant2.c jutils.c jmemmgr.c jmemnobs.c \
jaricom.c jcarith.c jdarith.c \
turbojpeg.c transupp.c jdatadst-tj.c jdatasrc-tj.c
LOCAL_SRC_FILES:= $(libjpeg_SOURCES_DIST)
LOCAL_SHARED_LIBRARIES := libcutils
LOCAL_STATIC_LIBRARIES := libsimd
LOCAL_ARM_MODE=arm
LOCAL_C_INCLUDES := $(LOCAL_PATH)
LOCAL_CFLAGS :=-O3 -fstrict-aliasing -fprefetch-loop-arrays -DANDROID \
-DANDROID_TILE_BASED_DECODE -DENABLE_ANDROID_NULL_CONVERT -D__ARM_HAVE_NEON
AM_CFLAGS := -march=armv7-a -mfpu=neon
AM_CCASFLAGS := -march=armv7-a -mfpu=neon
LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_STATIC_LIBRARY)
LOCAL_MODULE_TAGS := debug
LOCAL_MODULE := libjpeg
include $(BUILD_SHARED_LIBRARY)
5、在终端输入ndk-build，进行交叉编译，结果如下：
root@zhangjie:/home/libjpeg-turbo-1.2.1/jni# ndk-build Compile arm : jpeg <= yuv2jpg.c Compile arm : jpeg <= jcapimin.c Compile arm : jpeg <= jcapistd.c Compile arm : jpeg <= jccoefct.c Compile arm : jpeg <= jccolor.c Compile arm : jpeg <= jcdctmgr.c Compile arm : jpeg <= jchuff.c Compile arm : jpeg <= jcinit.c Compile arm : jpeg <= jcmainct.c Compile arm : jpeg <= jcmarker.c Compile arm : jpeg <= jcmaster.c Compile arm : jpeg <= jcomapi.c Compile arm : jpeg <= jcparam.c Compile arm : jpeg <= jcphuff.c Compile arm : jpeg <= jcprepct.c Compile arm : jpeg <= jcsample.c Compile arm : jpeg <= jctrans.c Compile arm : jpeg <= jdapimin.c Compile arm : jpeg <= jdapistd.c Compile arm : jpeg <= jdatadst.c Compile arm : jpeg <= jdatasrc.c Compile arm : jpeg <= jdcoefct.c Compile arm : jpeg <= jdcolor.c Compile arm : jpeg <= jddctmgr.c Compile arm : jpeg <= jdhuff.c Compile arm : jpeg <= jdinput.c Compile arm : jpeg <= jdmainct.c Compile arm : jpeg <= jdmarker.c Compile arm : jpeg <= jdmaster.c Compile arm : jpeg <= jdmerge.c Compile arm : jpeg <= jdphuff.c Compile arm : jpeg <= jdpostct.c Compile arm : jpeg <= jdsample.c Compile arm : jpeg <= jdtrans.c Compile arm : jpeg <= jerror.c Compile arm : jpeg <= jquant1.c Compile arm : jpeg <= jquant2.c Compile arm : jpeg <= jutils.c Compile arm : jpeg <= jmemmgr.c Compile arm : jpeg <= jmemnobs.c Compile arm : jpeg <= jaricom.c Compile arm : jpeg <= jcarith.c Compile arm : jpeg <= jdarith.c Compile arm : jpeg <= turbojpeg.c Compile arm : jpeg <= transupp.c Compile arm : jpeg <= jdatadst-tj.c Compile arm : jpeg <= jdatasrc-tj.c Compile arm : simd <= jsimd_arm_neon.S Compile arm : simd <= jsimd_arm.c StaticLibrary : libsimd.a SharedLibrary : libjpeg.so Install : libjpeg.so => libs/armeabi/libjpeg.so
6、在libjpeg-turbo源码里面中的example.c中的方法是用rgb2jpeg的功能，其中write_JPEG_file函数是将rgb2jpeg，read_JPEG_file使用来解码文件的，代码如下：
/* * example.c * * This file illustrates how to use the IJG code as a subroutine library * to read or write JPEG image files. You should look at this code in * conjunction with the documentation file libjpeg.txt. * * This code will not do anything useful as-is, but it may be helpful as a * skeleton for constructing routines that call the JPEG library. * * We present these routines in the same coding style used in the JPEG code * (ANSI function definitions, etc); but you are of course free to code your * routines in a different style if you prefer. */ #include <stdio.h> /* * Include file for users of JPEG library. * You will need to have included system headers that define at least * the typedefs FILE and size_t before you can include jpeglib.h. * (stdio.h is sufficient on ANSI-conforming systems.) * You may also wish to include "jerror.h". */ #include "jpeglib.h" /* * <setjmp.h> is used for the optional error recovery mechanism shown in * the second part of the example. */ #include <setjmp.h> /******************** JPEG COMPRESSION SAMPLE INTERFACE *******************/ /* This half of the example shows how to feed data into the JPEG compressor. * We present a minimal version that does not worry about refinements such * as error recovery (the JPEG code will just exit() if it gets an error). */ /* * IMAGE DATA FORMATS: * * The standard input image format is a rectangular array of pixels, with * each pixel having the same number of "component" values (color channels). * Each pixel row is an array of JSAMPLEs (which typically are unsigned chars). * If you are working with color data, then the color values for each pixel * must be adjacent in the row; for example, R,G,B,R,G,B,R,G,B,... for 24-bit * RGB color. * * For this example, we'll assume that this data structure matches the way * our application has stored the image in memory, so we can just pass a * pointer to our image buffer. In particular, let's say that the image is * RGB color and is described by: */ extern JSAMPLE * image_buffer; /* Points to large array of R,G,B-order data */ extern int image_height; /* Number of rows in image */ extern int image_width; /* Number of columns in image */ /* * Sample routine for JPEG compression. We assume that the target file name * and a compression quality factor are passed in. */ GLOBAL(void) write_JPEG_file (char * filename, int quality) { /* 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, "wb")) == NULL) { fprintf(stderr, "can't open %s\n", filename); exit(1); } 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 = 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, quality, 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! */ } /* * SOME FINE POINTS: * * In the above loop, we ignored the return value of jpeg_write_scanlines, * which is the number of scanlines actually written. We could get away * with this because we were only relying on the value of cinfo.next_scanline, * which will be incremented correctly. If you maintain additional loop * variables then you should be careful to increment them properly. * Actually, for output to a stdio stream you needn't worry, because * then jpeg_write_scanlines will write all the lines passed (or else exit * with a fatal error). Partial writes can only occur if you use a data * destination module that can demand suspension of the compressor. * (If you don't know what that's for, you don't need it.) * * If the compressor requires full-image buffers (for entropy-coding * optimization or a multi-scan JPEG file), it will create temporary * files for anything that doesn't fit within the maximum-memory setting. * (Note that temp files are NOT needed if you use the default parameters.) * On some systems you may need to set up a signal handler to ensure that * temporary files are deleted if the program is interrupted. See libjpeg.txt. * * Scanlines MUST be supplied in top-to-bottom order if you want your JPEG * files to be compatible with everyone else's. If you cannot readily read * your data in that order, you'll need an intermediate array to hold the * image. See rdtarga.c or rdbmp.c for examples of handling bottom-to-top * source data using the JPEG code's internal virtual-array mechanisms. */ /******************** JPEG DECOMPRESSION SAMPLE INTERFACE *******************/ /* This half of the example shows how to read data from the JPEG decompressor. * It's a bit more refined than the above, in that we show: * (a) how to modify the JPEG library's standard error-reporting behavior; * (b) how to allocate workspace using the library's memory manager. * * Just to make this example a little different from the first one, we'll * assume that we do not intend to put the whole image into an in-memory * buffer, but to send it line-by-line someplace else. We need a one- * scanline-high JSAMPLE array as a work buffer, and we will let the JPEG * memory manager allocate it for us. This approach is actually quite useful * because we don't need to remember to deallocate the buffer separately: it * will go away automatically when the JPEG object is cleaned up. */ /* * ERROR HANDLING: * * The JPEG library's standard error handler (jerror.c) is divided into * several "methods" which you can override individually. This lets you * adjust the behavior without duplicating a lot of code, which you might * have to update with each future release. * * Our example here shows how to override the "error_exit" method so that * control is returned to the library's caller when a fatal error occurs, * rather than calling exit() as the standard error_exit method does. * * We use C's setjmp/longjmp facility to return control. This means that the * routine which calls the JPEG library must first execute a setjmp() call to * establish the return point. We want the replacement error_exit to do a * longjmp(). But we need to make the setjmp buffer accessible to the * error_exit routine. To do this, we make a private extension of the * standard JPEG error handler object. (If we were using C++, we'd say we * were making a subclass of the regular error handler.) * * Here's the extended error handler struct: */ struct my_error_mgr { struct jpeg_error_mgr pub; /* "public" fields */ jmp_buf setjmp_buffer; /* for return to caller */ }; typedef struct my_error_mgr * my_error_ptr; /* * Here's the routine that will replace the standard error_exit method: */ METHODDEF(void) my_error_exit (j_common_ptr cinfo) { /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */ my_error_ptr myerr = (my_error_ptr) cinfo->err; /* Always display the message. */ /* We could postpone this until after returning, if we chose. */ (*cinfo->err->output_message) (cinfo); /* Return control to the setjmp point */ longjmp(myerr->setjmp_buffer, 1); } /* * Sample routine for JPEG decompression. We assume that the source file name * is passed in. We want to return 1 on success, 0 on error. */ GLOBAL(int) read_JPEG_file (char * filename) { /* This struct contains the JPEG decompression parameters and pointers to * working space (which is allocated as needed by the JPEG library). */ struct jpeg_decompress_struct cinfo; /* We use our private extension JPEG error handler. * Note that this struct must live as long as the main JPEG parameter * struct, to avoid dangling-pointer problems. */ struct my_error_mgr jerr; /* More stuff */ FILE * infile; /* source file */ JSAMPARRAY buffer; /* Output row buffer */ int row_stride; /* physical row width in output buffer */ /* In this example we want to open the input file before doing anything else, * so that the setjmp() error recovery below can assume the file is open. * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that * requires it in order to read binary files. */ if ((infile = fopen(filename, "rb")) == NULL) { fprintf(stderr, "can't open %s\n", filename); return 0; } /* Step 1: allocate and initialize JPEG decompression object */ /* We set up the normal JPEG error routines, then override error_exit. */ cinfo.err = jpeg_std_error(&jerr.pub); jerr.pub.error_exit = my_error_exit; /* Establish the setjmp return context for my_error_exit to use. */ if (setjmp(jerr.setjmp_buffer)) { /* If we get here, the JPEG code has signaled an error. * We need to clean up the JPEG object, close the input file, and return. */ jpeg_destroy_decompress(&cinfo); fclose(infile); return 0; } /* Now we can initialize the JPEG decompression object. */ jpeg_create_decompress(&cinfo); /* Step 2: specify data source (eg, a file) */ jpeg_stdio_src(&cinfo, infile); /* Step 3: read file parameters with jpeg_read_header() */ (void) jpeg_read_header(&cinfo, TRUE); /* We can ignore the return value from jpeg_read_header since * (a) suspension is not possible with the stdio data source, and * (b) we passed TRUE to reject a tables-only JPEG file as an error. * See libjpeg.txt for more info. */ /* Step 4: set parameters for decompression */ /* In this example, we don't need to change any of the defaults set by * jpeg_read_header(), so we do nothing here. */ /* Step 5: Start decompressor */ (void) jpeg_start_decompress(&cinfo); /* We can ignore the return value since suspension is not possible * with the stdio data source. */ /* We may need to do some setup of our own at this point before reading * the data. After jpeg_start_decompress() we have the correct scaled * output image dimensions available, as well as the output colormap * if we asked for color quantization. * In this example, we need to make an output work buffer of the right size. */ /* JSAMPLEs per row in output buffer */ row_stride = cinfo.output_width * cinfo.output_components; /* Make a one-row-high sample array that will go away when done with image */ buffer = (*cinfo.mem->alloc_sarray) ((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1); /* Step 6: while (scan lines remain to be read) */ /* jpeg_read_scanlines(...); */ /* Here we use the library's state variable cinfo.output_scanline as the * loop counter, so that we don't have to keep track ourselves. */ while (cinfo.output_scanline < cinfo.output_height) { /* jpeg_read_scanlines expects an array of pointers to scanlines. * Here the array is only one element long, but you could ask for * more than one scanline at a time if that's more convenient. */ (void) jpeg_read_scanlines(&cinfo, buffer, 1); /* Assume put_scanline_someplace wants a pointer and sample count. */ put_scanline_someplace(buffer[0], row_stride); } /* Step 7: Finish decompression */ (void) jpeg_finish_decompress(&cinfo); /* We can ignore the return value since suspension is not possible * with the stdio data source. */ /* Step 8: Release JPEG decompression object */ /* This is an important step since it will release a good deal of memory. */ jpeg_destroy_decompress(&cinfo); /* After finish_decompress, we can close the input file. * Here we postpone it until after no more JPEG errors are possible, * so as to simplify the setjmp error logic above. (Actually, I don't * think that jpeg_destroy can do an error exit, but why assume anything...) */ fclose(infile); /* At this point you may want to check to see whether any corrupt-data * warnings occurred (test whether jerr.pub.num_warnings is nonzero). */ /* And we're done! */ return 1; } /* * SOME FINE POINTS: * * In the above code, we ignored the return value of jpeg_read_scanlines, * which is the number of scanlines actually read. We could get away with * this because we asked for only one line at a time and we weren't using * a suspending data source. See libjpeg.txt for more info. * * We cheated a bit by calling alloc_sarray() after jpeg_start_decompress(); * we should have done it beforehand to ensure that the space would be * counted against the JPEG max_memory setting. In some systems the above * code would risk an out-of-memory error. However, in general we don't * know the output image dimensions before jpeg_start_decompress(), unless we * call jpeg_calc_output_dimensions(). See libjpeg.txt for more about this. * * Scanlines are returned in the same order as they appear in the JPEG file, * which is standardly top-to-bottom. If you must emit data bottom-to-top, * you can use one of the virtual arrays provided by the JPEG memory manager * to invert the data. See wrbmp.c for an example. * * As with compression, some operating modes may require temporary files. * On some systems you may need to set up a signal handler to ensure that * temporary files are deleted if the program is interrupted. See libjpeg.txt. */