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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
/*
* Copyright (C) 2014 The CyanogenMod Project
*
* 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 org.cyanogenmod.wallpapers.photophase.utils;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.BitmapFactory.Options;
import android.graphics.Matrix;
import android.media.ExifInterface;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
/**
* A helper class for deal with Bitmaps
*/
public class BitmapUtils {
/**
* Method that decodes a bitmap
*
* @param bitmap The bitmap buffer to decode
* @return Bitmap The decoded bitmap
*/
public static Bitmap decodeBitmap(InputStream bitmap) {
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inPreferQualityOverSpeed = false;
options.inPreferredConfig = Bitmap.Config.RGB_565;
options.inDither = false;
return BitmapFactory.decodeStream(bitmap, null, options);
}
/**
* Method that decodes a bitmap
*
* @param file The bitmap file to decode
* @param reqWidth The request width
* @param reqHeight The request height
* @return Bitmap The decoded bitmap
*/
public static Bitmap decodeBitmap(File file, int reqWidth, int reqHeight) {
// First decode with inJustDecodeBounds=true to check dimensions
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
options.inPreferredConfig = Bitmap.Config.RGB_565;
BitmapFactory.decodeFile(file.getAbsolutePath(), options);
// Calculate inSampleSize (use 1024 as maximum size, the minimum supported
// by all the gles20 devices)
options.inSampleSize = calculateBitmapRatio(
options,
Math.min(reqWidth, 1024),
Math.min(reqHeight, 1024));
// Decode the bitmap with inSampleSize set
options.inJustDecodeBounds = false;
options.inPreferQualityOverSpeed = false;
options.inPurgeable = true;
options.inInputShareable = true;
Bitmap bitmap = BitmapFactory.decodeFile(file.getAbsolutePath(), options);
if (bitmap == null) {
return null;
}
// Test if the bitmap has exif format, and decode properly
Bitmap out = decodeExifBitmap(file, bitmap);
if (!out.equals(bitmap)) {
bitmap.recycle();
bitmap = null;
}
return out;
}
/**
* Method that decodes an Exif bitmap
*
* @param file The file to decode
* @param src The bitmap reference
* @return Bitmap The decoded bitmap
*/
private static Bitmap decodeExifBitmap(File file, Bitmap src) {
try {
// Try to load the bitmap as a bitmap file
ExifInterface exif = new ExifInterface(file.getAbsolutePath());
int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, 1);
if (orientation == 0) {
return src;
}
Matrix matrix = new Matrix();
if (orientation == 6) {
matrix.postRotate(90);
} else if (orientation == 3) {
matrix.postRotate(180);
} else if (orientation == 8) {
matrix.postRotate(270);
}
// Rotate the bitmap
return Bitmap.createBitmap(src, 0, 0, src.getWidth(), src.getHeight(), matrix, true);
} catch (IOException e) {
// Ignore
}
return src;
}
/**
* Method that calculate the bitmap size prior to decode
*
* @param options The bitmap factory options
* @param reqWidth The request width
* @param reqHeight The request height
* @return int The picture ratio
*/
private static int calculateBitmapRatio(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) {
// Calculate ratios of height and width to requested height and width
final int heightRatio = Math.round((float) height / (float) reqHeight);
final int widthRatio = Math.round((float) width / (float) reqWidth);
// Choose the smallest ratio as inSampleSize value, this will guarantee
// a final image with both dimensions larger than or equal to the
// requested height and width.
inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
}
return inSampleSize;
}
}
|
