android 图片占用内存大小及加载解析

1
Bitmap bmp = BitmapFactory.decodeResource(getResources(), R.mipmap.testxh);

1
2
3
4
5
6
7
8
9
10
public int getBitmapSize(Bitmap bitmap){
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT){
//API 19
return bitmap.getAllocationByteCount();
} else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR1){//API 12
return bitmap.getByteCount();
} else {
return bitmap.getRowBytes() * bitmap.getHeight(); //earlier version
}
}

1
2
3
4
5
6
7
8
9
/**
* 返回位图像素的行的字节数，由位图存储的像素值有关，它会根据Color类进行打包
*/
public final int getRowBytes() {
if (mRecycled) {
Log.w(TAG, "Called getRowBytes() on a recycle()'d bitmap! This is undefined behavior!");
}
return nativeRowBytes(mNativePtr);
}

1
private static native int nativeRowBytes(long nativeBitmap);

1
2
3
4
static jint Bitmap_rowBytes(JNIEnv* env, jobject, jlong bitmapHandle) {
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle)
return static_cast<jint>(bitmap->rowBytes());
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
size_t SkBitmap::ComputeRowBytes(Config c, int width) {
return SkColorTypeMinRowBytes(SkBitmapConfigToColorType(c), width);
}
SkImageInfo.h
static int SkColorTypeBytesPerPixel(SkColorType ct) {
static const uint8_t gSize[] = {
0,
// Unknown
1,
// Alpha_8
2,
// RGB_565
2,
// ARGB_4444
4,
// RGBA_8888
4,
// BGRA_8888
1,
// kIndex_8
};
SK_COMPILE_ASSERT(SK_ARRAY_COUNT(gSize) == (size_t)(kLastEnum_SkColorType + 1),
size_mismatch_with_SkColorType_enum);
SkASSERT((size_t)ct < SK_ARRAY_COUNT(gSize));
return gSize[ct];
}
static inline size_t SkColorTypeMinRowBytes(SkColorType ct, int width) {
return width * SkColorTypeBytesPerPixel(ct);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 /**
* @param res
包含图片资源的Resources对象，一般通过getResources()即可获取
* @param id
资源文件id, 如R.mipmap.ic_laucher
* @param opts
可为空，控制采样或图片是否需要完全解码还是只需要获取图片大小
* @return
解码的bitmap
*/
public static Bitmap decodeResource(Resources res, int id, Options opts) {
Bitmap bm = null;
InputStream is = null;
try {
final TypedValue value = new TypedValue();
//1.读取资源返回数据流格式，最终会调用AssetManager的openNonAsset方法进行读取资源
is = res.openRawResource(id, value);
//2. 根据数据流格式进行解码，在直接加载res资源时，一般opts为空
bm = decodeResourceStream(res, value, is, null, opts);
} catch (Exception e) {
} 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;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
* 根据输入的数据流确码成一个新的bitmap, 数据流是从资源处获取，在这里可以根据规则对图片进行一些缩放操作
*/
public static Bitmap decodeResourceStream(Resources res, TypedValue value,
InputStream is, Rect pad, Options opts) {
if (opts == null) {//如果没有设置Options，系统会新创建一个Options对象
opts = new Options();
}
//若没有设置opts，inDensity就是初始值0,它代表图片资源密度
if (opts.inDensity == 0 && value != null) {
final int density = value.density;
if (density == TypedValue.DENSITY_DEFAULT) { //如果density等于0,则采用默认值160
opts.inDensity = DisplayMetrics.DENSITY_DEFAULT;
} else if (density != TypedValue.DENSITY_NONE) {//如果没有设置资源密度，则图片不会被缩放
opts.inDensity = density;//这里density的值对应的就是资源密度值
}
}
//此时inTargetDensity默认也为0
if (opts.inTargetDensity == 0 && res != null) {
//将手机的屏幕密度值赋值给最终图片显示的密度
opts.inTargetDensity = res.getDisplayMetrics().densityDpi;
}
return decodeStream(is, pad, opts);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
static jobject doDecode(JNIEnv* env, SkStreamRewindable* stream, jobject padding, jobject options) {
......
if (env->GetBooleanField(options, gOptions_scaledFieldID)) {
//资源本身的密度
const int density = env->GetIntField(options, gOptions_densityFieldID);
//最终加载的图片的密度
const int targetDensity = env->GetIntField(options, gOptions_targetDensityFieldID);
//手机的屏幕密度
const int screenDensity = env->GetIntField(options, gOptions_screenDensityFieldID);
//如果资源密度不为0，手机屏幕密度也不为0, 资源的密度与屏幕密度不相等时，图片缩放比例=屏幕密度/资源密度，如对于三星手机屏幕密度为640,如果图片放在文件夹为xhdpi 320下，则scale=2,会对图片长宽均放大2倍
if (density != 0 && targetDensity != 0 && density != screenDensity) {
scale = (float) targetDensity / density;
}
}
}
const bool willScale = scale != 1.0f;//判断是否需要缩放
......
SkBitmap decodingBitmap;
if (!decoder->decode(stream, &decodingBitmap, prefColorType,decodeMode)) {
return nullObjectReturn("decoder->decode returned false");
}
//这里这个deodingBitmap就是解码出来的bitmap，大小是图片原始的大小
int scaledWidth = decodingBitmap.width();
int scaledHeight = decodingBitmap.height();
if (willScale && decodeMode != SkImageDecoder::kDecodeBounds_Mode) {
scaledWidth = int(scaledWidth * scale + 0.5f);//这里+0.5是保证在图片缩小时，可能会出小数，这里加0.5是为了让除后的数向上取整
scaledHeight = int(scaledHeight * scale + 0.5f);
}
if (willScale) {
const float sx = scaledWidth / float(decodingBitmap.width());
const float sy = scaledHeight / float(decodingBitmap.height());
// 设置解码图片的colorType
SkColorType colorType = colorTypeForScaledOutput(decodingBitmap.colorType());
//设置图片的宽高
outputBitmap->setInfo(SkImageInfo::Make(scaledWidth, scaledHeight,
colorType, decodingBitmap.alphaType()));
if (!outputBitmap->allocPixels(outputAllocator, NULL)) {
return nullObjectReturn("allocation failed for scaled bitmap");
}
if (outputAllocator != &javaAllocator) {
outputBitmap->eraseColor(0);
}
SkPaint paint;
paint.setFilterLevel(SkPaint::kLow_FilterLevel);
SkCanvas canvas(*outputBitmap);
canvas.scale(sx, sy);//根据缩放比画出图像
canvas.drawBitmap(decodingBitmap, 0.0f, 0.0f, &paint);//将图片画到画布上
}
......
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//读取手机本地的图片资源
public static Bitmap decodeFile(String pathName, Options opts) {
Bitmap bm = null;
InputStream stream = null;
try {
stream = new FileInputStream(pathName);
//调用decodeStream将数据流转成bitmap
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
}
}
}
return bm;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/**
* 从网络中获取图片，先获取数据流，再转成Bitmap
* @return
*/
public Bitmap getBitmapByPicUrl(String picurl) throws IOException {
InputStream inputStream = null;
URL url = new URL(picurl);
//服务器地址
if (url != null) {
//打开连接
HttpURLConnection httpURLConnection = (HttpURLConnection)url.openConnection();
httpURLConnection.setConnectTimeout(3000);//设置网络连接超时的时间为3秒
httpURLConnection.setRequestMethod("GET");
//设置请求方法为GET
httpURLConnection.setDoInput(true);
//打开输入流
int responseCode = httpURLConnection.getResponseCode();
// 获取服务器响应值
if (responseCode == HttpURLConnection.HTTP_OK) {
//正常连接
inputStream = httpURLConnection.getInputStream();
//获取输入流
}
}
return BitmapFactory.decodeStream(inputStream);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
/**
*根据输入的数据流确码成一个新的bitmap
*
* @param is
从源数据获取的输入数居流，用于解码成bitmap
* @param outPadding
如果不为空，返回bitmap的边距，这个会加入到图片所占内存大小里
* @param opts
可以为空; 用来控制图片的采样率和图片是否需要完全解码，还是只需要获取图片大小
* @return
解码后的图片
*/
public static Bitmap decodeStream(InputStream is, Rect outPadding, Options opts) {
if (is == null) {
return null;
}
Bitmap bm = null;
Trace.traceBegin(Trace.TRACE_TAG_GRAPHICS, "decodeBitmap");
try {//如果数据流来自资源，则直接调用native方法
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;
}

1
private static native Bitmap nativeDecodeAsset(long nativeAsset, Rect padding, Options opts);

1
2
3
4
5
6
7
8
9
10
11
 /**
* is不得为空，会根据流的需要提供一个缓冲区
*/
private static Bitmap decodeStreamInternal(InputStream is, Rect outPadding, Options opts) {
// ASSERT(is != null);
byte [] tempStorage = null;
if (opts != null) tempStorage = opts.inTempStorage;
//如果Options没有提供inTempStorage参数会默认提供一个16M的缓冲区
if (tempStorage == null) tempStorage = new byte[DECODE_BUFFER_SIZE];
return nativeDecodeStream(is, tempStorage, outPadding, opts);
}

1
2

Rect padding, Options opts);

1
2
3
4
5
6
7
8
9
10
//解码Asset资源的数据流
static jobject nativeDecodeAsset(JNIEnv* env, jobject clazz, jint native_asset,
jobject padding, jobject options) {
return nativeDecodeAssetScaled(env, clazz, native_asset, padding, options, false, 1.0f);
}
//解码纯数据流
static jobject nativeDecodeStream(JNIEnv* env, jobject clazz, jobject is, jbyteArray storage,
jobject padding, jobject options) {
return nativeDecodeStreamScaled(env, clazz, is, storage, padding, options, false, 1.0f);
}

1
2
3
4
5
6
7
8
9
10
11
static jobject nativeDecodeStreamScaled(JNIEnv* env, jobject clazz, jobject is, jbyteArray storage,
jobject padding, jobject options, jboolean applyScale, jfloat scale) {
jobject bitmap = NULL;
SkStream* stream = CreateJavaInputStreamAdaptor(env, is, storage, 0);
if (stream) {
// for now we don't allow purgeable with java inputstreams
bitmap = doDecode(env, stream, padding, options, false, false, applyScale, scale);
stream->unref();
}
return bitmap;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
static jobject doDecode(JNIEnv* env, SkStream* stream, jobject padding,
jobject options, bool allowPurgeable, bool forcePurgeable = false,
bool applyScale = false, float scale = 1.0f) {
int sampleSize = 1;
SkImageDecoder::Mode mode = SkImageDecoder::kDecodePixels_Mode;
SkBitmap::Config prefConfig = SkBitmap::kARGB_8888_Config;//直接采用ARGB_8888的色彩格式
bool doDither = true;
bool isMutable = false;
bool willScale = applyScale && scale != 1.0f;//上面传的参数applyScale为false，所以willScale为false
bool isPurgeable = !willScale &&
(forcePurgeable || (allowPurgeable && optionsPurgeable(env, options)));
bool preferQualityOverSpeed = false;
jobject javaBitmap = NULL;
if (options != NULL) {
sampleSize = env->GetIntField(options, gOptions_sampleSizeFieldID);//获取采样率
if (optionsJustBounds(env, options)) {//是否只加载图片边界，而不解码
mode = SkImageDecoder::kDecodeBounds_Mode;
}
//省略初始化代码
}
//省略一堆代码
SkImageDecoder* decoder = SkImageDecoder::Factory(stream);
int scaledWidth = decoded->width();//获取解码图片的宽度
int scaledHeight = decoded->height();//获取解码后图片的调节度
if (willScale && mode != SkImageDecoder::kDecodeBounds_Mode) {//由于willScale为false，这里不会运行
scaledWidth = int(scaledWidth * scale + 0.5f);
scaledHeight = int(scaledHeight * scale + 0.5f);
}
// update options (if any)
if (options != NULL) {
env->SetIntField(options, gOptions_widthFieldID, scaledWidth);
env->SetIntField(options, gOptions_heightFieldID, scaledHeight);
env->SetObjectField(options, gOptions_mimeFieldID,
getMimeTypeString(env, decoder->getFormat()));
}
if (mode == SkImageDecoder::kDecodeBounds_Mode) {//如果只获取图片大小，这里不会返回bitmap
return NULL;
}
if (padding) {//如果设置了padding，则会把边矩算进去
if (peeker.fPatchIsValid) {
GraphicsJNI::set_jrect(env, padding,
peeker.fPatch->paddingLeft, peeker.fPatch->paddingTop,
peeker.fPatch->paddingRight, peeker.fPatch->paddingBottom);
} else {
GraphicsJNI::set_jrect(env, padding, -1, -1, -1, -1);
}
}
SkPixelRef* pr;
if (isPurgeable) {
pr = installPixelRef(bitmap, stream, sampleSize, doDither);
} else {
pr = bitmap->pixelRef();
}
return GraphicsJNI::createBitmap(env, bitmap, javaAllocator.getStorageObj(),
isMutable, ninePatchChunk);//创建bitmap
}

1
2
3
4
5
BitmapFactory.Options ops = new BitmapFactory.Options();
int targetDensity = getResources().getDisplayMetrics().densityDpi;
ops.inDensity = 240;
ops.inTargetDensity = 480;
Bitmap assetsbmp = BitmapFactory.decodeStream(stream, null, ops);