We Keep Coding

BitmapFactory.Options inSampleSize documentation confusion

Following is the code from the official Android documentation.
https://developer.android.com/training/camera/photobasics
private void setPic() {
// Get the dimensions of the View
int targetW = imageView.getWidth();
int targetH = imageView.getHeight();
// Get the dimensions of the bitmap
BitmapFactory.Options bmOptions = new BitmapFactory.Options();
bmOptions.inJustDecodeBounds = true;
int photoW = bmOptions.outWidth;
int photoH = bmOptions.outHeight;
// Determine how much to scale down the image
int scaleFactor = Math.min(photoW/targetW, photoH/targetH);
// Decode the image file into a Bitmap sized to fill the View
bmOptions.inJustDecodeBounds = false;
bmOptions.inSampleSize = scaleFactor;
bmOptions.inPurgeable = true;
Bitmap bitmap = BitmapFactory.decodeFile(currentPhotoPath, bmOptions);
imageView.setImageBitmap(bitmap);
}
I am not able to understand the use of Math.min function here. So what Math.min is doing, is selecting the smallest ratio between photoW/targetW and photoH/targetH.
Now, let us suppose there is an image whose width is two times larger than that of the imageView and its height is four times larger than that of the imageView. So, the ratios come to be two and four and the Math.min function will give us two in the scaleFactor.
And what bmOptions.inSampleSize does is
https://developer.android.com/reference/android/graphics/BitmapFactory.Options#inSampleSize
If set to a value > 1, requests the decoder to subsample the original
image, returning a smaller image to save memory. The sample size is
the number of pixels in either dimension that corresponds to a single
pixel in the decoded bitmap. For example, inSampleSize == 4 returns an
image that is 1/4 the width/height of the original
According to this, our image will get half it's size whose height will still be two times bigger than that of the imageView.
Shouldn't we use Math.max or am I missing something?

OutOfMemory Exception with Bitmap

i had a problem with load images as bitmap , therefore i use the method:
"decodeSampledBitmapFromFile"
(the implementation is included)
and i also saved all the bitmaps on the SdCard and every time that i need the Bitmap i load it from the Path which it's stored with the parameters:
decodeSampledBitmapFromFile(path,150,100);
Bitmap image_profile =decodeSampledBitmapFromFile(path,150,100);
and set the image Bitmap into the imageView that i need (every time that i need a image i load it from the sdCard.
however i still get an OutOfMemoryException after load about 20 images.
So, what is the solution for the OutOfMemoryException?
why even after load small number of images (about 20) i get an OutOfMemoryException?
what is the secret of application like facebook, instagram or youtube that they suceesseed
to load huge number of images without Exception?
i tried everything however i still get Exception.
anyOne has further suggestions what can i implement in order to avoid this exception?
thanks alot
public static Bitmap decodeSampledBitmapFromFile(String path, int reqWidth, int reqHeight)
{ // BEST QUALITY MATCH
// First decode with inJustDecodeBounds=true to check dimensions
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile(path, options);
// Calculate inSampleSize
// Raw height and width of image
final int height = options.outHeight;
final int width = options.outWidth;
options.inPreferredConfig = Bitmap.Config.RGB_565;
int inSampleSize = 1;
if (height > reqHeight) {
inSampleSize = Math.round((float)height / (float)reqHeight);
}
int expectedWidth = width / inSampleSize;
if (expectedWidth > reqWidth) {
//if(Math.round((float)width / (float)reqWidth) > inSampleSize) // If bigger SampSize..
inSampleSize = Math.round((float)width / (float)reqWidth);
}
options.inSampleSize = inSampleSize;
// Decode bitmap with inSampleSize set
options.inJustDecodeBounds = false;
return BitmapFactory.decodeFile(path, options);
}

You're probably loading the images and then they're not getting recycled or collected by the garbage collector so they're still taking up memory.
Since it sounds like you're only using one image at a time, I guess you could try to manually get rid of the references to the Bitmap that you don't need anymore and then call System.gc() to free up the memory?
If not, I would look into an LruCache.
Google has a good tutorial on it: http://developer.android.com/reference/android/util/LruCache.html
This tutorial also helped me when I first used an LruCache for my game:
http://andrewbrobinson.com/2012/03/05/image-caching-in-android/

Android, Java: Resized Bitmap ignores bitmap options

I am creating this Android game with Java. However, I load the bitmaps and then resize them to fit screens and such (dpi isn't really exact). BUT my thought is also to load the bitmaps in 16b (mBitmapOptions.inPreferredConfig = Bitmap.Config.ARGB_4444) for devices with a small amount of ram. But when I resize the bitmaps they seem to go back to 32b (Bitmap.Config.ARGB_8888).
This is how I declare the options:
mBitmapOptions = new BitmapFactory.Options();
mBitmapOptions.inPreferredConfig = Bitmap.Config.ARGB_4444;
This is how I load the bitmaps:
mBitmaps.add(getResizedBitmap(BitmapFactory.decodeResource(mResources, imagePath, mBitmapOptions)));
And this is the getResizeBitmap method:
public Bitmap getResizedBitmap(Bitmap bm)
{
//Original size
int width = bm.getWidth();
int height = bm.getHeight();
//New size (percent)
float newWidth = 1 * mScaleWidth;
float newHeight = 1 * mScaleHeight;
//Create the matrix
Matrix matrix = new Matrix();
matrix.postScale(newWidth, newHeight);
//Recreate the new Bitmap
Bitmap resizedBitmap = Bitmap.createBitmap(bm, 0, 0, width, height, matrix, true);
//Recycle the old Bitmap
bm.recycle();
return resizedBitmap;
}
Any ideas why the new Bitmap ignores the options?

Why don't you use the createScaledBitmap method? It should preserve the options. In your case, you are creating a completely new Bitmap and it probably applies a default config.
EDIT: Another option would be to use your code and add a call to the copy method like this:
Bitmap smallerBitmap = resizedBitmap.copy (Bitmap.Config.ARGB_4444, false);
resizedBitmap.recycle ();
However, I don't think this will have a nice performance...

Loading an image in android allocates a large memory

I am using an image of size 720X1136 as splash screen for my app targeted only for Samsung Galaxy Nexus phones. The actual file size is 513Kb(Found from Browser). When the activity calls the onCreate method and sets the content view the log mentions about a memory allocation of 13.5 MB.
This is the activity which I am loading with an image in background.
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical">
<ImageView android:src="#drawable/splashscreen"
android:id="#+id/splashscreen"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
/>
<WebView xmlns:android="http://schemas.android.com/apk/res/android"
android:visibility="invisible"
android:id="#+id/webview"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
/>
</RelativeLayout>
How can I reduce this memory allocation?
Thanks

Use #drawable/splashscreen this Image as 9-Patch image
then it will reduce memory allocation

Here are Step for sort out of your problem.
mRelativeLayout=(RelativeLayout)findViewById(R.id.relative_view);
intializeScreenSize();
mBitmap=decodeSampledBitmapFromResource(getResources(),R.drawable.splash_background,width,height);
mDrawable=new BitmapDrawable(getResources(), mBitmap);
mRelativeLayout.setBackgroundDrawable(mDrawable);
public static Bitmap decodeSampledBitmapFromResource(Resources res,
int resId, int reqWidth, int reqHeight) {
// First decode with inJustDecodeBounds=true to check dimensions
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeResource(res, resId, options);
// Calculate inSampleSize
options.inSampleSize = calculateInSampleSize(options, reqWidth,
reqHeight);
// Decode bitmap with inSampleSize set
options.inJustDecodeBounds = false;
return BitmapFactory.decodeResource(res, resId, options);
}
public void intializeScreenSize(){
DisplayMetrics displaymetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
height= displaymetrics.heightPixels;
width= displaymetrics.widthPixels;
}
public static int calculateInSampleSize(BitmapFactory.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) {
if (width > height) {
inSampleSize = Math.round((float) height / (float) reqHeight);
} else {
inSampleSize = Math.round((float) width / (float) reqWidth);
}
}
return inSampleSize;
}
Here are some link related to Load Bitmap in android.
SO Answer
Load Bitmap Efficiently

13mb is fine and within the limits. Whenever this splash screen is gone, the bitmap will be recycled and the memory will be repurposed to the rest of your app.
Tricks you could use to try to minimise this memory foot print is:
. use a 9 patch to stretch the borders of the image (if the design allows)
. lower the quality of the image (it will look crap)

As Alex Orlov stated: "the size on disk has nothing to do with the size of bitmap in memory. In the first case the image is compressed, bitmap, on the other hand, is just a raw set of pixels." However even considering it is stored as a raw image, 20MB is stil way too much. If we consider 4B per pixel, that would be 5Mpix image, but that one you have posted is definittely smaller.
I had similar problem: I was loading an image that has 8MB in raw format, however, 32MB were allocated for it. I later found out this was caused by dpi scaling. If you have your image in "drawable" folder, it will be automatically scaled according to current screen dpi. I have an XHDPI screen, so my image was scaled 2x horizontally and 2x vertically, that's why it took 4x more memory.
You can find more about how dpi works here: http://developer.android.com/guide/practices/screens_support.html
If you don't want to use this automatic android feature and scale images yourself, simply rename your "drawable" folder to "drawable-nodpi". All images in "drawable" folder tagged as "nodpi" will be loaded as they are.

nobody needs pixel perfect splash screen, you may easily reduce the image size to the half of the original, this will save you 3/4 of the memory footprint.
on another note, i'd recommend to avoid splash screens at all, here's a nice essay on this topic: "Splash screens are evil, don’t use them!", otherwise you may search google for "splash screens are evil" and get more arguments against using them.

Why can't I call a method with a parameter of the wrong type?

I tried using:
//decodes image and scales it to reduce memory consumption
private Bitmap decodeFile(File f)
{
try {
//Decode image size
BitmapFactory.Options o = new BitmapFactory.Options();
o.inJustDecodeBounds = true;
BitmapFactory.decodeStream(new FileInputStream(f),null,o);
//The new size we want to scale to
final int REQUIRED_SIZE=70;
//Find the correct scale value. It should be the power of 2.
int scale=1;
while(o.outWidth/scale/2>=REQUIRED_SIZE && o.outHeight/scale/2>=REQUIRED_SIZE)
scale*=2;
//Decode with inSampleSize
BitmapFactory.Options o2 = new BitmapFactory.Options();
o2.inSampleSize=scale;
return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);
} catch (FileNotFoundException e) {}
return null;
}
then
R.drawable.image = decodeFile(R.drawable.image);
How to use this method? R.drawable.image is integer, so it gives me error, how can I decode file? I add 240kb image to textview.

Well you've said yourself, R.drawable.image is an integer - but you're trying to pass it to a method accepting a File, and then assign the return value (a Bitmap) back to it.
Additionally, catching FileNotFoundException like that and just swallowing it is a really bad idea - why don't you just declare that the method might throw the exception?
It's not clear what you're really trying to do - or what R.drawable.image is really meant to achieve - but in order to use the method you've got, you clearly need a File.

Are you trying to convert a drawable to a File and then that File to a Bitmap?
This will allow you to decode a drawable right to a Bitmap:
Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.image );

I think you may be looking for something like this:
Resources res = getResources();
Drawable image = res.getDrawable(R.drawable.image);
Android allows you to access the images in your drawable folders using the Resources class. They also handle the scaling for you by using different folders for different resolution images. Additionally, if you have a widget defined in xml, you can assign it a source drawable that way using the android:src attribute, in your case it would be android:src="#drawable/image". Take a look at
http://developer.android.com/guide/topics/resources/drawable-resource.html
and
http://developer.android.com/training/multiscreen/screensizes.html
for more information about how you can handle images with Android and how the OS helps you choose a properly scaled image, respectively.
Edit: One more thing, if you're just trying to set the image resource for something like an ImageView, you can use imageView.setImageResource(R.drawable.image) so that you don't have to create a Drawable or Resources object in your code. If you need to do something to the image before you set it though, there are corresponding setImageDrawable and setImageBitmap methods.

VM wont let us allocate 6291456 bytes
Your image is about 6 Megabyte uncompressed, see http://developer.android.com/training/displaying-bitmaps/index.html
And if you want to load a downscaled version of that image which might be required since you seem to be low on memory it would work with about the following code
/** decodes image from resources to max maxSize x maxSize pixels */
private Bitmap decodeFile(Context context, int resId, int maxSize) {
Resources res = context.getResources();
// Decode image size
BitmapFactory.Options o = new BitmapFactory.Options();
o.inJustDecodeBounds = true;
BitmapFactory.decodeResource(res, resId, o);
// Find the correct scale value. It should be the power of 2.
int scale = 1;
while (o.outWidth / scale / 2 >= maxSize && o.outHeight / scale / 2 >= maxSize)
scale *= 2;
// Decode with inSampleSize
o.inJustDecodeBounds = false;
o.inSampleSize = scale;
return BitmapFactory.decodeResource(res, resId, o);
}