android bitmap image resize

Resize a large bitmap file to scaled output file on Android


I have a large bitmap (say 3888×2592) in a file. Now, I want to resize that bitmap to 800×533 and save it to another file.
I normally would scale the bitmap by calling Bitmap.createBitmap method but it needs a source bitmap as the first argument, which I can’t provide because loading the original image into a Bitmap object would of course exceed the memory (see here, for example).

I also can’t read the bitmap with, for example, BitmapFactory.decodeFile(file, options), providing a BitmapFactory.Options.inSampleSize, because I want to resize it to an exact width and height. Using inSampleSize would resize the bitmap to 972×648 (if I use inSampleSize=4) or to 778×518 (if I use inSampleSize=5, which isn’t even a power of 2).

I would also like to avoid reading the image using inSampleSize with, for example, 972×648 in a first step and then resizing it to exactly 800×533 in a second step, because the quality would be poor compared to a direct resizing of the original image.

To sum up my question:
Is there a way to read a large image file with 10MP or more and save it to a new image file, resized to a specific new width and height, without getting an OutOfMemory exception?

I also tried BitmapFactory.decodeFile(file, options) and setting the Options.outHeight and Options.outWidth values manually to 800 and 533, but it doesn’t work that way.



No. I’d love for someone to correct me, but I accepted the load/resize approach you tried as a compromise.

Here are the steps for anyone browsing:

  1. Calculate the maximum possible inSampleSize that still yields an image larger than your target.
  2. Load the image using BitmapFactory.decodeFile(file, options), passing inSampleSize as an option.
  3. Resize to the desired dimensions using Bitmap.createScaledBitmap().


  • I tried to avoid that. So there’s no way to directly resize a large image in only one step?

    – Manuel

    Jul 26, 2010 at 9:08

  • 2

    Not to my knowledge, but don’t let that stop you from exploring this further.

    – Justin

    Jul 26, 2010 at 12:18

  • Alright, I will take this for my accepted answer so far. If I find out any other methods, I will let you know.

    – Manuel

    Jul 26, 2010 at 19:01

  • As PSIXO mentioned in an answer, you may also want to use android:largeHeap if you still have issues after using inSampleSize.

    Mar 17, 2015 at 2:45

  • bitmap variable was getting empty

    – Prasad

    Mar 16, 2018 at 8:57


Justin answer translated to code (works perfect for me):

private Bitmap getBitmap(String path) {

Uri uri = getImageUri(path);
InputStream in = null;
try {
    final int IMAGE_MAX_SIZE = 1200000; // 1.2MP
    in = mContentResolver.openInputStream(uri);

    // Decode image size
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeStream(in, null, options);

    int scale = 1;
    while ((options.outWidth * options.outHeight) * (1 / Math.pow(scale, 2)) > 
          IMAGE_MAX_SIZE) {
    Log.d(TAG, "scale = " + scale + ", orig-width: " + options.outWidth + ", 
       orig-height: " + options.outHeight);

    Bitmap resultBitmap = null;
    in = mContentResolver.openInputStream(uri);
    if (scale > 1) {
        // scale to max possible inSampleSize that still yields an image
        // larger than target
        options = new BitmapFactory.Options();
        options.inSampleSize = scale;
        resultBitmap = BitmapFactory.decodeStream(in, null, options);

        // resize to desired dimensions
        int height = resultBitmap.getHeight();
        int width = resultBitmap.getWidth();
        Log.d(TAG, "1th scale operation dimenions - width: " + width + ",
           height: " + height);

        double y = Math.sqrt(IMAGE_MAX_SIZE
                / (((double) width) / height));
        double x = (y / height) * width;

        Bitmap scaledBitmap = Bitmap.createScaledBitmap(resultBitmap, (int) x, 
           (int) y, true);
        resultBitmap = scaledBitmap;

    } else {
        resultBitmap = BitmapFactory.decodeStream(in);

    Log.d(TAG, "bitmap size - width: " +resultBitmap.getWidth() + ", height: " + 
    return resultBitmap;
} catch (IOException e) {
    Log.e(TAG, e.getMessage(),e);
    return null;


  • 15

    Makes it hard to read when you use variables like “b” but good answer non the less.

    Aug 14, 2012 at 10:05

  • @Ofir : getImageUri(path); what i have to pass in this method?

    – Biginner

    May 28, 2013 at 8:21

  • 1

    Instead of (wh)/Math.pow(scale, 2) it is more efficient to use (wh) >> scale.

    Sep 23, 2014 at 13:12

  • 2

    Don’t call System.gc() please

    – gw0

    Apr 11, 2015 at 14:24

  • Thanks @Ofir but this transformation doesn’t conserve the image orientation :-/

    Sep 24, 2015 at 5:22


This is ‘Mojo Risin’s and ‘Ofir’s solutions “combined”. This will give you a proportionally resized image with the boundaries of max width and max height.

  1. It only reads meta data to get the original size (options.inJustDecodeBounds)
  2. It uses a rought resize to save memory (itmap.createScaledBitmap)
  3. It uses a precisely resized image based on the rough Bitamp created earlier.

For me it has been performing fine on 5 MegaPixel images an below.

    int inWidth = 0;
    int inHeight = 0;

    InputStream in = new FileInputStream(pathOfInputImage);

    // decode image size (decode metadata only, not the whole image)
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeStream(in, null, options);
    in = null;

    // save width and height
    inWidth = options.outWidth;
    inHeight = options.outHeight;

    // decode full image pre-resized
    in = new FileInputStream(pathOfInputImage);
    options = new BitmapFactory.Options();
    // calc rought re-size (this is no exact resize)
    options.inSampleSize = Math.max(inWidth/dstWidth, inHeight/dstHeight);
    // decode full image
    Bitmap roughBitmap = BitmapFactory.decodeStream(in, null, options);

    // calc exact destination size
    Matrix m = new Matrix();
    RectF inRect = new RectF(0, 0, roughBitmap.getWidth(), roughBitmap.getHeight());
    RectF outRect = new RectF(0, 0, dstWidth, dstHeight);
    m.setRectToRect(inRect, outRect, Matrix.ScaleToFit.CENTER);
    float[] values = new float[9];

    // resize bitmap
    Bitmap resizedBitmap = Bitmap.createScaledBitmap(roughBitmap, (int) (roughBitmap.getWidth() * values[0]), (int) (roughBitmap.getHeight() * values[4]), true);

    // save image
        FileOutputStream out = new FileOutputStream(pathOfOutputImage);
        resizedBitmap.compress(Bitmap.CompressFormat.JPEG, 80, out);
    catch (Exception e)
        Log.e("Image", e.getMessage(), e);
catch (IOException e)
    Log.e("Image", e.getMessage(), e);