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這三個分量就是之後代碼中需要的三個參數：

[cpp]
                      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++; 
                                } 
                        } 

                        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函數的聲明：

[cpp]
#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];  
    <SPAN style="COLOR: #33cc00"><SPAN style="COLOR: #330033">rawData[0]= yData; 
    rawData[1] = uData; 
    rawData[2] = vData;</SPAN> 
</SPAN> 
    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;  
}  

#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#

[cpp]
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 

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文件，如下：

[cpp]
# 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) 

# 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，進行交叉編譯，結果如下：

[cpp]
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 

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使用來解碼文件的，代碼如下：

[html]
/* 
 * 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. 
 */ 
<SPAN style="COLOR: #cc9933"> 
GLOBAL(void) 
write_JPEG_file (char * filename, int quality)</SPAN> 
{ 
  /* 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. 
 */ 
 
<SPAN style="COLOR: #ff6600"> 
GLOBAL(int) 
read_JPEG_file (char * filename)</SPAN> 
{ 
  /* 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. 
 */