Question

In my app I load an image as 32 bit (ARGB_8888) this way:

 Bitmap.Config mBitmapConfig;
 mBitmapConfig = Bitmap.Config.ARGB_8888; 
 BitmapFactory.Options options = new BitmapFactory.Options();
 options.inPreferredConfig = mBitmapConfig;
 mBitmap = BitmapFactory.decodeFile(SourceFileName, options);

Then scale:

mBitmap = Bitmap.createScaledBitmap(mBitmap, iW, iH, true); 

If I use for scaling the same Width and Height of the original bitmap, it is 1/2 of the size in megabytes (I’m watching the heap size).
Changing the value “ARGB_8888” to “RGB_565” (24 bit) gives the same size in megabytes after scaling.

Can someone explain this phenomenon and may be give me an advice, how to scale bitmaps in 32 bit color space?
Thanks!

Answer 1

I looked up the method createScaledBitmap in the source for the Bitmap class (Link):

public static Bitmap createScaledBitmap(Bitmap src, int dstWidth,
        int dstHeight, boolean filter) {
    Matrix m;
    synchronized (Bitmap.class) {
        // small pool of just 1 matrix
        m = sScaleMatrix;
        sScaleMatrix = null;
    }

    if (m == null) {
        m = new Matrix();
    }

    final int width = src.getWidth();
    final int height = src.getHeight();
    final float sx = dstWidth  / (float)width;
    final float sy = dstHeight / (float)height;
    m.setScale(sx, sy);
    Bitmap b = Bitmap.createBitmap(src, 0, 0, width, height, m, filter);

    synchronized (Bitmap.class) {
        // do we need to check for null? why not just assign everytime?
        if (sScaleMatrix == null) {
            sScaleMatrix = m;
        }
    }

    return b;
}

And the call to createBitmap() should return your unchanged source bitmap due to this check in the method body:

    if (!source.isMutable() && x == 0 && y == 0 && width == source.getWidth() &&
            height == source.getHeight() && (m == null || m.isIdentity())) {
        return source;
    }

Looking at just this it would seem that your original bitmap is returned, But, if your bitmap happens to be mutable, you effectively skip this check and end up here:

    if (m == null || m.isIdentity()) {
        bitmap = createBitmap(neww, newh,
                source.hasAlpha() ? Config.ARGB_8888 : Config.RGB_565);
        paint = null;   // not needed
    }

As you are not performing any scaling, your matrix will be the identity matrix, and the condition is satisfied. The bitmap created is, as you can see, dependent on the alpha in the source bitmap. If no alpha is present, you end up with a result bitmap with the RGB_565 format rather than the ARGB_8888.

So, to scale and preserve the 32-bit format, your bitmap should either be immutable or use an Alpha channel.