Android性能优化之Bitmap图片优化详解

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(); 
  //质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中 
  bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos); 
  int options = 100; 
  //循环判断如果压缩后图片是否大于50kb,大于继续压缩 
  while ( baos.toByteArray().length / 1024>50) { 
  //清空baos 
  baos.reset(); 
  bitmap.compress(Bitmap.CompressFormat.JPEG, options, baos); 
  options -= 10;//每次都减少10 
  } 
  //把压缩后的数据baos存放到ByteArrayInputStream中 
  ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray()); 
  //把ByteArrayInputStream数据生成图片 
  Bitmap newBitmap = BitmapFactory.decodeStream(isBm, null, null); 
  return newBitmap; 
 } 

 /**
  * 按图片尺寸压缩 参数是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,进行压缩避免在生成图片（BitmapFactory.decodeStream）时溢出
   os.reset();
   bitmap.compress(Bitmap.CompressFormat.JPEG, 50, os);//这里压缩50%，把压缩后的数据存放到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;
 }


 /**
  * 动态计算出图片的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;
 }
 //指定压缩数据源
 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;
 //为压缩设定参数，包括图像大小，颜色空间
 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];
  //写入数据
  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转换为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转换为rgb数据
 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);
 //进行压缩
 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)