Bitmap decodeFile(...)
Bitmap decodeResource(...)
Bitmap decodeByteArray(...)
Bitmap decodeStream(...)
Bitmap decodeFileDescriptor(...)

 public static Bitmap decodeFile(String pathName, Options opts) {
 Bitmap bm = null;
 InputStream stream = null;
 try {
  stream = new FileInputStream(pathName);
  bm = decodeStream(stream, null, opts);
 } catch (Exception e) {
  /* do nothing.
  If the exception happened on open, bm will be null.
  */
  Log.e("BitmapFactory", "Unable to decode stream: " + e);
 } finally {
  if (stream != null) {
  try {
   stream.close();
  } catch (IOException e) {
   // do nothing here
  }
  }
 }

public static Bitmap decodeResource(Resources res, int id, Options opts) {
 Bitmap bm = null;
 InputStream is = null; 

 try {
  final TypedValue value = new TypedValue();
  is = res.openRawResource(id, value);

  bm = decodeResourceStream(res, value, is, null, opts);
 } catch (Exception e) {
  /* do nothing.
  If the exception happened on open, bm will be null.
  If it happened on close, bm is still valid.
  */
 } finally {
  try {
  if (is != null) is.close();
  } catch (IOException e) {
  // Ignore
  }
 }

 if (bm == null && opts != null && opts.inBitmap != null) {
  throw new IllegalArgumentException("Problem decoding into existing bitmap");
 }

 return bm;
 }

 public static Bitmap decodeStream(InputStream is, Rect outPadding, Options opts) {
 // we don't throw in this case, thus allowing the caller to only check
 // the cache, and not force the image to be decoded.
 if (is == null) {
  return null;
 }

 Bitmap bm = null;

 Trace.traceBegin(Trace.TRACE_TAG_GRAPHICS, "decodeBitmap");
 try {
  if (is instanceof AssetManager.AssetInputStream) {
  final long asset = ((AssetManager.AssetInputStream) is).getNativeAsset();
  bm = nativeDecodeAsset(asset, outPadding, opts);
  } else {
  bm = decodeStreamInternal(is, outPadding, opts);
  }

  if (bm == null && opts != null && opts.inBitmap != null) {
  throw new IllegalArgumentException("Problem decoding into existing bitmap");
  }

  setDensityFromOptions(bm, opts);
 } finally {
  Trace.traceEnd(Trace.TRACE_TAG_GRAPHICS);
 }

 return bm;
 }

private static Bitmap decodeStreamInternal(InputStream is, Rect outPadding, Options opts) {
 // ASSERT(is != null);
 byte [] tempStorage = null;
 if (opts != null) tempStorage = opts.inTempStorage;
 if (tempStorage == null) tempStorage = new byte[DECODE_BUFFER_SIZE];
 return nativeDecodeStream(is, tempStorage, outPadding, opts);
 }

nativeDecodeAsset()
nativeDecodeStream()

decodeFile->decodeStream
decodeResource->decodeResourceStream->decodeStream

public static Bitmap decodeResourceStream(Resources res, TypedValue value,
  InputStream is, Rect pad, Options opts) {

 if (opts == null) {
  opts = new Options();
 }

 if (opts.inDensity == 0 && value != null) {
  final int density = value.density;
  if (density == TypedValue.DENSITY_DEFAULT) {
  opts.inDensity = DisplayMetrics.DENSITY_DEFAULT;
  } else if (density != TypedValue.DENSITY_NONE) {
  opts.inDensity = density;
  }
 }

 if (opts.inTargetDensity == 0 && res != null) {
  opts.inTargetDensity = res.getDisplayMetrics().densityDpi;
 }

 return decodeStream(is, pad, opts);
 }

opts.inTargetDensity = res.getDisplayMetrics().densityDpi;

private static void setDensityFromOptions(Bitmap outputBitmap, Options opts) {
 if (outputBitmap == null || opts == null) return;

 final int density = opts.inDensity;
 if (density != 0) {
  outputBitmap.setDensity(density);
  final int targetDensity = opts.inTargetDensity;
  if (targetDensity == 0 || density == targetDensity || density == opts.inScreenDensity) {
  return;
  }

  byte[] np = outputBitmap.getNinePatchChunk();
  final boolean isNinePatch = np != null && NinePatch.isNinePatchChunk(np);
  if (opts.inScaled || isNinePatch) {
  outputBitmap.setDensity(targetDensity);
  }
 } else if (opts.inBitmap != null) {
  // bitmap was reused, ensure density is reset
  outputBitmap.setDensity(Bitmap.getDefaultDensity());
 }
 }

 public static Bitmap compressImage(Bitmap bitmap){ 
  ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
  //質(zhì)量壓縮方法，這里100表示不壓縮，把壓縮后的數(shù)據(jù)存放到baos中 
  bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos); 
  int options = 100; 
  //循環(huán)判斷如果壓縮后圖片是否大于50kb,大于繼續(xù)壓縮 
  while ( baos.toByteArray().length / 1024>50) { 
  //清空baos 
  baos.reset(); 
  bitmap.compress(Bitmap.CompressFormat.JPEG, options, baos); 
  options -= 10;//每次都減少10 
  } 
  //把壓縮后的數(shù)據(jù)baos存放到ByteArrayInputStream中 
  ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray()); 
  //把ByteArrayInputStream數(shù)據(jù)生成圖片 
  Bitmap newBitmap = BitmapFactory.decodeStream(isBm, null, null); 
  return newBitmap; 
 } 

 /**
  * 按圖片尺寸壓縮 參數(shù)是bitmap
  * @param bitmap
  * @param pixelW
  * @param pixelH
  * @return
  */
 public static Bitmap compressImageFromBitmap(Bitmap bitmap, int pixelW, int pixelH) {
  ByteArrayOutputStream os = new ByteArrayOutputStream();
  bitmap.compress(Bitmap.CompressFormat.JPEG, 100, os);
  if( os.toByteArray().length / 1024>512) {//判斷如果圖片大于0.5M,進(jìn)行壓縮避免在生成圖片（BitmapFactory.decodeStream）時溢出
   os.reset();
   bitmap.compress(Bitmap.CompressFormat.JPEG, 50, os);//這里壓縮50%，把壓縮后的數(shù)據(jù)存放到baos中
  }
  ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
  BitmapFactory.Options options = new BitmapFactory.Options();
  options.inJustDecodeBounds = true;
  options.inPreferredConfig = Bitmap.Config.RGB_565;
  BitmapFactory.decodeStream(is, null, options);
  options.inJustDecodeBounds = false;
  options.inSampleSize = computeSampleSize(options , pixelH > pixelW ? pixelW : pixelH ,pixelW * pixelH );
  is = new ByteArrayInputStream(os.toByteArray());
  Bitmap newBitmap = BitmapFactory.decodeStream(is, null, options);
  return newBitmap;
 }


 /**
  * 動態(tài)計(jì)算出圖片的inSampleSize
  * @param options
  * @param minSideLength
  * @param maxNumOfPixels
  * @return
  */
 public static int computeSampleSize(BitmapFactory.Options options, int minSideLength, int maxNumOfPixels) {
  int initialSize = computeInitialSampleSize(options, minSideLength, maxNumOfPixels);
  int roundedSize;
  if (initialSize <= 8) {
   roundedSize = 1;
   while (roundedSize < initialSize) {
    roundedSize <<= 1;
   }
  } else {
   roundedSize = (initialSize + 7) / 8 * 8;
  }
  return roundedSize;
 }

 private static int computeInitialSampleSize(BitmapFactory.Options options, int minSideLength, int maxNumOfPixels) {
  double w = options.outWidth;
  double h = options.outHeight;
  int lowerBound = (maxNumOfPixels == -1) ? 1 : (int) Math.ceil(Math.sqrt(w * h / maxNumOfPixels));
  int upperBound = (minSideLength == -1) ? 128 :(int) Math.min(Math.floor(w / minSideLength), Math.floor(h / minSideLength));
  if (upperBound < lowerBound) {
   return lowerBound;
  }
  if ((maxNumOfPixels == -1) && (minSideLength == -1)) {
   return 1;
  } else if (minSideLength == -1) {
   return lowerBound;
  } else {
   return upperBound;
  }
 }

boolean optimize_coding 
TRUE causes the compressor to compute optimal Huffman coding tables 
for the image. This requires an extra pass over the data and 
therefore costs a good deal of space and time. The default is 
FALSE, which tells the compressor to use the supplied or default 
Huffman tables. In most cases optimal tables save only a few percent 
of file size compared to the default tables. Note that when this is 
TRUE, you need not supply Huffman tables at all, and any you do 
supply will be overwritten.

NDK=/opt/ndk/android-ndk-r10e/
PLATFORM=$NDK/platforms/android-9/arch-arm/
PREBUILT=$NDK/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86/
CC=$PREBUILT/bin/arm-linux-androideabi-gcc
./configure --prefix=/home/linc/jpeg-9b/jni/dist --host=arm CC="$CC --sysroot=$PLATFORM"

$ sh config.sh 
...
checking whether to build shared libraries... no
checking whether to build static libraries... yes
...
config.status: creating Makefile
config.status: creating jconfig.h

jni$ make install-libLTLIBRARIES
libtool: install: ranlib /home/linc/jpeg-9b/jni/dist/lib/libjpeg.a

LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)

LOCAL_ARM_MODE := arm

LOCAL_SRC_FILES :=jaricom.c jcapimin.c jcapistd.c jcarith.c jccoefct.c jccolor.c \
  jcdctmgr.c jchuff.c jcinit.c jcmainct.c jcmarker.c jcmaster.c \
  jcomapi.c jcparam.c jcprepct.c jcsample.c jctrans.c jdapimin.c \
  jdapistd.c jdarith.c jdatadst.c jdatasrc.c jdcoefct.c jdcolor.c \
  jddctmgr.c jdhuff.c jdinput.c jdmainct.c jdmarker.c jdmaster.c \
  jdmerge.c jdpostct.c jdsample.c jdtrans.c jerror.c jfdctflt.c \
  jfdctfst.c jfdctint.c jidctflt.c jidctfst.c jidctint.c jquant1.c \
  jquant2.c jutils.c jmemmgr.c jmemnobs.c

LOCAL_C_INCLUDES := $(LOCAL_PATH)
LOCAL_CFLAGS += -O3 -fstrict-aliasing -fprefetch-loop-arrays \
 -DANDROID -DANDROID_TILE_BASED_DECODE -DENABLE_ANDROID_NULL_CONVERT


LOCAL_MODULE := libjpeg

LOCAL_MODULE_TAGS := optional

# unbundled branch, built against NDK.
LOCAL_SDK_VERSION := 17

include $(BUILD_SHARED_LIBRARY)

$ ndk-build
[armeabi] Compile arm : jpeg <= jaricom.c
...
[armeabi] Compile arm : jpeg <= jmemnobs.c
[armeabi] SharedLibrary : libjpeg.so
[armeabi] Install  : libjpeg.so => libs/armeabi/libjpeg.so

#include <string.h>
#include <android/bitmap.h>
#include <android/log.h>
#include <jni.h>
#include <stdio.h>
#include <setjmp.h>
#include <math.h>
#include <stdint.h>
#include <time.h>
#include "jpeglib.h"
#include "cdjpeg.h"  /* Common decls for cjpeg/djpeg applications */
#include "jversion.h"  /* for version message */
#include "config.h"

#define LOG_TAG "jni"
#define LOGW(...) __android_log_write(ANDROID_LOG_WARN,LOG_TAG,__VA_ARGS__)
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)

#define true 1
#define false 0

typedef uint8_t BYTE;

char *error;
struct my_error_mgr {
 struct jpeg_error_mgr pub;
 jmp_buf setjmp_buffer;
};

typedef struct my_error_mgr * my_error_ptr;

METHODDEF(void)
my_error_exit (j_common_ptr cinfo)
{
 my_error_ptr myerr = (my_error_ptr) cinfo->err;
 (*cinfo->err->output_message) (cinfo);
 error=myerr->pub.jpeg_message_table[myerr->pub.msg_code];
 LOGE("jpeg_message_table[%d]:%s", myerr->pub.msg_code,myerr->pub.jpeg_message_table[myerr->pub.msg_code]);
 // LOGE("addon_message_table:%s", myerr->pub.addon_message_table);
// LOGE("SIZEOF:%d",myerr->pub.msg_parm.i[0]);
// LOGE("sizeof:%d",myerr->pub.msg_parm.i[1]);
 longjmp(myerr->setjmp_buffer, 1);
}
//圖片壓縮方法
int generateJPEG(BYTE* data, int w, int h, int quality,
  const char* outfilename, jboolean optimize) {
 int nComponent = 3;

 struct jpeg_compress_struct jcs;

 struct my_error_mgr jem;

 jcs.err = jpeg_std_error(&jem.pub);
 jem.pub.error_exit = my_error_exit;
  if (setjmp(jem.setjmp_buffer)) {
   return 0;
   }
  //為JPEG對象分配空間并初始化
 jpeg_create_compress(&jcs);
 //獲取文件信息
 FILE* f = fopen(outfilename, "wb");
 if (f == NULL) {
  return 0;
 }
 //指定壓縮數(shù)據(jù)源
 jpeg_stdio_dest(&jcs, f);
 jcs.image_width = w;
 jcs.image_height = h;
 if (optimize) {
  LOGI("optimize==ture");
 } else {
  LOGI("optimize==false");
 }

 jcs.arith_code = false;
 jcs.input_components = nComponent;
 if (nComponent == 1)
  jcs.in_color_space = JCS_GRAYSCALE;
 else
  jcs.in_color_space = JCS_RGB;

 jpeg_set_defaults(&jcs);
 jcs.optimize_coding = optimize;
 //為壓縮設(shè)定參數(shù)，包括圖像大小，顏色空間
 jpeg_set_quality(&jcs, quality, true);
 //開始壓縮
 jpeg_start_compress(&jcs, TRUE);

 JSAMPROW row_pointer[1];
 int row_stride;
 row_stride = jcs.image_width * nComponent;
 while (jcs.next_scanline < jcs.image_height) {
  row_pointer[0] = &data[jcs.next_scanline * row_stride];
  //寫入數(shù)據(jù)
  jpeg_write_scanlines(&jcs, row_pointer, 1);
 }

 if (jcs.optimize_coding) {
   LOGI("optimize==ture");
  } else {
   LOGI("optimize==false");
  }
 //壓縮完畢
 jpeg_finish_compress(&jcs);
 //釋放資源
 jpeg_destroy_compress(&jcs);
 fclose(f);

 return 1;
}

typedef struct {
 uint8_t r;
 uint8_t g;
 uint8_t b;
} rgb;

//將java string轉(zhuǎn)換為char*
char* jstrinTostring(JNIEnv* env, jbyteArray barr) {
 char* rtn = NULL;
 jsize alen = (*env)->GetArrayLength(env, barr);
 jbyte* ba = (*env)->GetByteArrayElements(env, barr, 0);
 if (alen > 0) {
  rtn = (char*) malloc(alen + 1);
  memcpy(rtn, ba, alen);
  rtn[alen] = 0;
 }
 (*env)->ReleaseByteArrayElements(env, barr, ba, 0);
 return rtn;
}
//jni方法入口
jstring Java_net_bither_util_NativeUtil_compressBitmap(JNIEnv* env,
  jobject thiz, jobject bitmapcolor, int w, int h, int quality,
  jbyteArray fileNameStr, jboolean optimize) {

 AndroidBitmapInfo infocolor;
 BYTE* pixelscolor;
 int ret;
 BYTE * data;
 BYTE *tmpdata;
 char * fileName = jstrinTostring(env, fileNameStr);
 //解碼Android bitmap信息，并存儲值infocolor中
 if ((ret = AndroidBitmap_getInfo(env, bitmapcolor, &infocolor)) < 0) {
  LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);
  return (*env)->NewStringUTF(env, "0");;
 }
 if ((ret = AndroidBitmap_lockPixels(env, bitmapcolor, &pixelscolor)) < 0) {
  LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
 }

 BYTE r, g, b;
 data = NULL;
 data = malloc(w * h * 3);
 tmpdata = data;
 int j = 0, i = 0;
 int color;
 //將bitmap轉(zhuǎn)換為rgb數(shù)據(jù)
 for (i = 0; i < h; i++) {
  for (j = 0; j < w; j++) {
   color = *((int *) pixelscolor);
   r = ((color & 0x00FF0000) >> 16);
   g = ((color & 0x0000FF00) >> 8);
   b = color & 0x000000FF;
   *data = b;
   *(data + 1) = g;
   *(data + 2) = r;
   data = data + 3;
   pixelscolor += 4;

  }

 }
 AndroidBitmap_unlockPixels(env, bitmapcolor);
 //進(jìn)行壓縮
 int resultCode= generateJPEG(tmpdata, w, h, quality, fileName, optimize);
 free(tmpdata);
 if(resultCode==0){
  jstring result=(*env)->NewStringUTF(env, error);
  error=NULL;
  return result;
 }
 return (*env)->NewStringUTF(env, "1"); //success
}

LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)

LOCAL_SRC_FILES:= jpeg_compress.cpp

LOCAL_MODULE:= jtest

LOCAL_LDLIBS :=-llog
LOCAL_LDLIBS += $(LOCAL_PATH)/libjpeg.so
LOCAL_C_INCLUDES := $(LOCAL_PATH)

LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
LOCAL_MODULE_TAGS := debug

include $(BUILD_EXECUTABLE)