位图解码器BitmapDecoder

/*
* Copyright (C) 2013 Peng fei Pan <sky@xiaopan.me>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*   http://www.apache.org/licenses/LICENSE-2.0 *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

package me.xiaopan.android.graphics;

import java.io.FileDescriptor;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

import android.content.Context;
import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.BitmapFactory.Options;
import android.graphics.Rect;
import android.net.Uri;
import android.util.TypedValue;

/**
* 位图解码器
*/
public class BitmapDecoder {
/**
* 单张图片最大像素数
*/
private int maxNumOfPixels;

/**
* 最小边长，默认为-1
*/
private int minSlideLength;

/**
* 创建一个位图解码器，此解码器将根据最大像素数来缩小位图值合适的尺寸
* @param maxNumOfPixels
*/
public BitmapDecoder(int maxNumOfPixels){
this.maxNumOfPixels = maxNumOfPixels;
this.minSlideLength = -1;
}

/**
* 创建一个位图解码器，最大像素数默认为虚拟机可用最大内存的八分之一再除以4，这样可以保证图片不会太大导致内存溢出
*/
public BitmapDecoder(){
this((int) (Runtime.getRuntime().maxMemory()/8/4));
}

/**
* 从字节数组中解码位图
* @param data
* @param offset
* @param length
* @param options
* @return
*/
public Bitmap decodeByteArray(byte[] data, int offset, int length, Options options){
if(options == null){
options = new Options();
}
options.inJustDecodeBounds = true;
BitmapFactory.decodeByteArray(data, offset, length, options);
options.inSampleSize = computeSampleSize(options, minSlideLength, maxNumOfPixels);
options.inJustDecodeBounds = false;
return BitmapFactory.decodeByteArray(data, offset, length, options);
}

/**
* 从字节数组中解码位图
* @param data
* @param offset
* @param length
* @return
*/
public Bitmap decodeByteArray(byte[] data, int offset, int length){
return decodeByteArray(data, offset, length, null);
}

/**
* 从字节数组中解码位图
* @param data
* @param options
* @return
*/
public Bitmap decodeByteArray(byte[] data, Options options){
return decodeByteArray(data, 0, data.length, options);
}

/**
* 从字节数组中解码位图
* @param data
* @return
*/
public Bitmap decodeByteArray(byte[] data){
return decodeByteArray(data, 0, data.length);
}

/**
* 从文件中解码位图
* @param filePath
* @param options
* @return
*/
public Bitmap decodeFile(String filePath, Options options){
if(options == null){
options = new Options();
}
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile(filePath, options);
options.inSampleSize = computeSampleSize(options, minSlideLength, maxNumOfPixels);
options.inJustDecodeBounds = false;
return BitmapFactory.decodeFile(filePath, options);
}

/**
* 从文件中解码位图
* @param filePath
* @return
*/
public Bitmap decodeFile(String filePath){
return decodeFile(filePath, null);
}

/**
* 从文件描述符中解码位图
* @param fd
* @param outPadding
* @param options
* @return
*/
public Bitmap decodeFileDescriptor(FileDescriptor fd, Rect outPadding, Options options){
if(options == null){
options = new Options();
}
options.inJustDecodeBounds = true;
BitmapFactory.decodeFileDescriptor(fd, outPadding, options);
options.inSampleSize = computeSampleSize(options, minSlideLength, maxNumOfPixels);
options.inJustDecodeBounds = false;
return BitmapFactory.decodeFileDescriptor(fd, outPadding, options);
}

/**
* 从文件描述符中解码位图
* @param fd
* @return
*/
public Bitmap decodeFileDescriptor(FileDescriptor fd){
return decodeFileDescriptor(fd, null, null);
}

/**
* 从资源文件中解码位图
* @param resource
* @param id
* @param options
* @return
*/
public Bitmap decodeResource(Resources resource, int id, Options options){
if(options == null){
options = new Options();
}
options.inJustDecodeBounds = true;
BitmapFactory.decodeResource(resource, id, options);
options.inSampleSize = computeSampleSize(options, minSlideLength, maxNumOfPixels);
options.inJustDecodeBounds = false;
return BitmapFactory.decodeResource(resource, id, options);
}

/**
* 从资源文件中解码位图
* @param resource
* @param id
* @return
*/
public Bitmap decodeResource(Resources resource, int id){
return decodeResource(resource, id, null);
}

/**
* 从资源文件流中解码位图
* @param resource
* @param value
* @param inputStreamCreator
* @param pad
* @param options
* @return
*/
public Bitmap decodeResourceStream(Resources resource, TypedValue value, InputStreamCreator inputStreamCreator, Rect pad, Options options){
if(options == null){
options = new Options();
}
options.inJustDecodeBounds = true;

InputStream inputStream = inputStreamCreator.onCreateInputStream();
if(inputStream == null) return null;
BitmapFactory.decodeResourceStream(resource, value, inputStream, pad, options);
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}

options.inSampleSize = computeSampleSize(options, minSlideLength, maxNumOfPixels);
options.inJustDecodeBounds = false;

inputStream = inputStreamCreator.onCreateInputStream();
if(inputStream == null) return null;
Bitmap bitmap = BitmapFactory.decodeResourceStream(resource, value, inputStream, pad, options);
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}

return bitmap;
}

/**
* 从流中解码位图
* @param inputStreamCreator
* @param outPadding
* @param options
* @return
*/
public Bitmap decodeStream(InputStreamCreator inputStreamCreator, Rect outPadding, Options options){
if(options == null){
options = new Options();
}
options.inJustDecodeBounds = true;

InputStream inputStream = inputStreamCreator.onCreateInputStream();
if(inputStream == null) return null;
BitmapFactory.decodeStream(inputStream, outPadding, options);
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}

options.inSampleSize = computeSampleSize(options, minSlideLength, maxNumOfPixels);
options.inJustDecodeBounds = false;

inputStream = inputStreamCreator.onCreateInputStream();
if(inputStream == null) return null;
Bitmap bitmap = BitmapFactory.decodeStream(inputStream, outPadding, options);
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}

return bitmap;
}

/**
* 从流中解码位图
* @param inputStreamCreator
* @return
*/
public Bitmap decodeStream(InputStreamCreator inputStreamCreator){
return decodeStream(inputStreamCreator, null, null);
}

/**
* 从Assets中解码位图
* @param context
* @param fileName
* @param outPadding
* @param options
* @return
*/
public Bitmap decodeFromAssets(final Context context, final String fileName, Rect outPadding, Options options){
return decodeStream(new InputStreamCreator() {
@Override
public InputStream onCreateInputStream() {
try {
return context.getAssets().open(fileName);
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
}, outPadding, options);
}

/**
* 从Assets中解码位图
* @param context
* @param fileName
* @return
*/
public Bitmap decodeFromAssets(Context context, String fileName){
return decodeFromAssets(context, fileName, null, null);
}

/**
* 从Uri中解码位图
* @param context
* @param uri
* @param outPadding
* @param options
* @return
*/
public Bitmap decodeUri(final Context context, final Uri uri, Rect outPadding, Options options){
return decodeStream(new InputStreamCreator() {
@Override
public InputStream onCreateInputStream() {
try {
return context.getContentResolver().openInputStream(uri);
} catch (FileNotFoundException e) {
e.printStackTrace();
return null;
}
}
}, outPadding, options);
}

/**
* 从Uri中解码位图
* @param context
* @param uri
* @return
*/
public Bitmap decodeUri(final Context context, final Uri uri){
return decodeUri(context, uri, null, null);
}

/**
* 获取最大像素数，一般由图片宽乘以高得出
* @return
*/
public int getMaxNumOfPixels() {
return maxNumOfPixels;
}

/**
* 设置最大像素数，将根据此像素数来缩小图片至合适的大小
* @param maxNumOfPixels 最大像素数，由图片宽乘以高得出
*/
public void setMaxNumOfPixels(int maxNumOfPixels) {
this.maxNumOfPixels = maxNumOfPixels;
}

/**
* 获取图片最小边长
* @return
*/
public int getMinSlideLength() {
return minSlideLength;
}

/**
* 设置图片最小边长，默认为-1
* @param minSlideLength
*/
public void setMinSlideLength(int minSlideLength) {
this.minSlideLength = minSlideLength;
}

/**
* 从字节数组中解码位图的尺寸
* @param data
* @param offset
* @param length
* @param options
* @return
*/
public static Options decodeSizeFromByteArray(byte[] data, int offset, int length, Options options){
if(options == null){
options = new Options();
}
options.inJustDecodeBounds = true;
BitmapFactory.decodeByteArray(data, offset, length, options);
options.inJustDecodeBounds = false;
return options;
}

/**
* 从字节数组中解码位图的尺寸
* @param data
* @param offset
* @param length
* @return
*/
public static Options decodeSizeFromByteArray(byte[] data, int offset, int length){
return decodeSizeFromByteArray(data, offset, length, null);
}

/**
* 从文件中解码位图的尺寸
* @param filePath
* @param options
* @return
*/
public static Options decodeSizeFromFile(String filePath, Options options){
if(options == null){
options = new Options();
}
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile(filePath, options);
options.inJustDecodeBounds = false;
return options;
}

/**
* 从文件中解码位图的尺寸
* @param filePath
* @return
*/
public static Options decodeSizeFromFile(String filePath){
return decodeSizeFromFile(filePath, null);
}

/**
* 从文件描述符中解码位图的尺寸
* @param fd
* @param outPadding
* @param options
* @return
*/
public static Options decodeSizeFromFileDescriptor(FileDescriptor fd, Rect outPadding, Options options){
if(options == null){
options = new Options();
}
options.inJustDecodeBounds = true;
BitmapFactory.decodeFileDescriptor(fd, outPadding, options);
options.inJustDecodeBounds = false;
return options;
}

/**
* 从文件描述符中解码位图的尺寸
* @param fd
* @return
*/
public static Options decodeSizeFromFileDescriptor(FileDescriptor fd){
return decodeSizeFromFileDescriptor(fd, null, null);
}

/**
* 从资源文件中解码位图的尺寸
* @param resource
* @param id
* @param options
* @return
*/
public static Options decodeSizeFromResource(Resources resource, int id, Options options){
if(options == null){
options = new Options();
}
options.inJustDecodeBounds = true;
BitmapFactory.decodeResource(resource, id, options);
options.inJustDecodeBounds = false;
return options;
}

/**
* 从资源文件中解码位图的尺寸
* @param resource
* @param id
* @return
*/
public static Options decodeSizeFromResource(Resources resource, int id){
return decodeSizeFromResource(resource, id, null);
}

/**
* 从资源流中解码位图的尺寸
* @param resource
* @param value
* @param inputStreamCreator
* @param pad
* @param options
* @return
*/
public static Options decodeSizeFromResourceStream(Resources resource, TypedValue value, InputStreamCreator inputStreamCreator, Rect pad, Options options){
if(options == null){
options = new Options();
}
options.inJustDecodeBounds = true;
InputStream inputStream = inputStreamCreator.onCreateInputStream();
if(inputStream == null) return options;
BitmapFactory.decodeResourceStream(resource, value, inputStream, pad, options);
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
options.inJustDecodeBounds = false;
return options;
}

/**
* 从流中解码位图的尺寸
* @param inputStreamCreator
* @param outPadding
* @param options
* @return
*/
public static Options decodeSizeFromStream(InputStreamCreator inputStreamCreator, Rect outPadding, Options options){
if(options == null){
options = new Options();
}
options.inJustDecodeBounds = true;
InputStream inputStream = inputStreamCreator.onCreateInputStream();
if(inputStream == null) return options;
BitmapFactory.decodeStream(inputStream, outPadding, options);
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
options.inJustDecodeBounds = false;
return options;
}

/**
* 从流中解码位图的尺寸
* @param inputStreamCreator
* @return
*/
public static Options decodeSizeFromStream(InputStreamCreator inputStreamCreator){
return decodeSizeFromStream(inputStreamCreator, null, null);
}

/**
* 从Assets中解码位图的尺寸
* @param context
* @param fileName
* @param outPadding
* @param options
* @return
*/
public static Options decodeSizeFromAssets(final Context context, final String fileName, Rect outPadding, Options options){
return decodeSizeFromStream(new InputStreamCreator() {
@Override
public InputStream onCreateInputStream() {
try {
return context.getAssets().open(fileName);
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
}, outPadding, options);
}

/**
* 从Assets中解码位图的尺寸
* @param context
* @param fileName
* @return
*/
public static Options decodeSizeFromAssets(Context context, String fileName){
return decodeSizeFromAssets(context, fileName, null, null);
}

/**
* 计算合适的缩小倍数，注意在调用此方法之前一定要先通过Options.inJustDecodeBounds属性来获取图片的宽高
* @param options
* @param minSideLength 用于指定最小宽度或最小高度
* @param maxNumOfPixels 最大尺寸，由最大宽高相乘得出
* @return
*/
public static int computeSampleSize(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(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;
}
}

public static int calculateInSampleSize(Options options, int reqWidth, int reqHeight) {
// Raw height and width of image
final int height = options.outHeight;
final int width = options.outWidth;
int inSampleSize = 1;

if (height > reqHeight || width > reqWidth) {

final int halfHeight = height / 2;
final int halfWidth = width / 2;

// Calculate the largest inSampleSize value that is a power of 2 and keeps both
// height and width larger than the requested height and width.
while ((halfHeight / inSampleSize) > reqHeight && (halfWidth / inSampleSize) > reqWidth) {
inSampleSize *= 2;
}
}

return inSampleSize;
}

public interface InputStreamCreator{
public InputStream onCreateInputStream();
}
}