Android based on Bitmap image compression method exploration

The image compression method explored in this paper is mainly based on Bitmap API implementation. In this paper, there are four kinds of compression methods: quality compression, sampling rate compression, Matrix scaling compression, image coding format compression

Introduction to Knowledge

Android images are mostly in the form of bitmaps, so compressing images is about reducing the size of the Bitmap. The size of a Bitmap can be calculated using the following formula: size = width * height * number of bytes per pixel. So compressing the image can be done by changing three variables in the formula.

The amount of space taken up by a single pixel varies in Android, as shown below

Android uses ARGB_8888 by default, so loading a 3000 * 4000 image takes up about 45MB of space by default, which is still a lot of 😂

The test code

fun showBitmapInfo(bitmap: Bitmap){
        Log.d("Tag"."Compressed image size:${bitmap.byteCount/1024/1024}MB, width:${bitmap.width}, height:${bitmap.height}")}Copy the code

The results of

The body of the

There are four types of compression

1. Quality compression

Quality compression is mainly achieved through bitmap.press (), method introduction

/ * * * *@paramFormat Format of compressed images *@paramQuality Prompt compressor, 0-100. The value is interpreted differently depending on the bitmap.pressformat. *@paramStream - An output stream that writes compressed data. *@returnTrue */ if successfully compressed to the specified stream
public boolean compress(CompressFormat format, int quality, OutputStream stream) {}Copy the code

CompressFormat stands for image compression format, and the Android source code contains five formats

Through the above description, we know that the commonly used compression format is JPEG, because PNG is lossless and WEBP is not long to use, the following practice to see the effect

The test code

/** ** compressed image quality */
fun getCompressBitmap(bitmap: Bitmap,quality:Int): Bitmap {
    val baos = ByteArrayOutputStream()
    bitmap.compress(Bitmap.CompressFormat.JPEG, quality, baos)
    val byte = baos.toByteArray()
    val ins = ByteArrayInputStream(byte)
    val bm = BitmapFactory.decodeStream(ins)
    ins.close()
    baos.close()
    return bm
}
Copy the code

The effect

According to the above log, you will see that quality compression does not change the size of the image in memory, because quality compression does not change the image resolution nor the individual pixel size of the image.

Then you might wonder: what’s the point of all this transformation and distortion when you can’t change the size?

A: The compress method writes a compressed version of the bitmap to the specified output stream. So it should affect the number of bytes in the output stream

validation

val baos = ByteArrayOutputStream()
bitmap.compress(Bitmap.CompressFormat.JPEG, quality, baos)
val byte = baos.toByteArray()
Log.d("Tag"."quality=$quality,byte-size=${byte.size}")
Copy the code

The result is really an impact on the number of bytes in the output stream

2. Sampling rate compression

Bitmapfactory. Options has a property called inSampleSize, which is used to compress the sampling rate in the system

/** * If set to a value greater than 1, request the decoder to re-sample the original image and return a smaller image to save memory. * The sample size is the number of pixels in any dimension that correspond to a single pixel in the decoded bitmap. For example, inSampleSize == 4 * returns an image that is 1/4 of the original width/height and 1/16 of the number of pixels. Any value less than or equal to 1 is the same as 1. * Note: The decoder uses final values based on powers of 2, and any other values will be rounded to the nearest power of 2. * * /
 public int inSampleSize;
Copy the code

Go straight to code

    /** * Calculate the scaling ratio according to the specified width and height */
    fun calculateInSampleSize(options: BitmapFactory.Options, reqWidth: Int, reqHeight: Int): Int {
        val height = options.outHeight
        val width = options.outWidth
        var inSampleSize = 1
        if (height > reqHeight || width > reqWidth) {
            val heightRatio = round(height.toFloat() / reqHeight.toFloat()).toInt()
            val widthRatio = round(width.toFloat() / reqWidth.toFloat()).toInt()
            inSampleSize = if (heightRatio < widthRatio) heightRatio else widthRatio
        }
        return inSampleSize
    }

    /** * get the zoomed image */
    fun getSmallBitmap(filePath: String,reqWidth: Int,reqHeight: Int): Bitmap {
        val options = BitmapFactory.Options()
        options.inJustDecodeBounds = true // Don't load bitmap into memory, just get its basic information
        BitmapFactory.decodeFile(filePath, options)
        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight)
        options.inJustDecodeBounds = false
        return BitmapFactory.decodeFile(filePath, options)
    }
Copy the code

The results of

We use a lot of sampling rate compression, because the size of the image we get may be quite large, but the size we display on the phone may not be that large, so we scale the image to the size we need.

3, zoom compression

This method mainly relies on Matrix Matrix transformation to process images. Matrix has a lot of apis for image transformation and I’m just going to use the zoom function, but you can figure it out

code

    /** * scaling by matrix */
    fun matrixBitmap(bitmap: Bitmap,scale:Float):Bitmap{
        val matrix = Matrix()
        matrix.setScale(scale,scale)
        var bm = Bitmap.createBitmap(bitmap,0.0,bitmap.width,bitmap.height,matrix,true)
        return bm
    }
Copy the code

When the zoom ratio is set to 0.5, the overall image is scaled to 1/4 of its original size

4, RGB_565 by changing the image format to achieve compression

The default format is ARGB_8888, so we can just change the options value

fun rgb565Bitmap(filePath: String):Bitmap{
        val options = BitmapFactory.Options()
        options.inPreferredConfig = Bitmap.Config.RGB_565
        var bitmap = BitmapFactory.decodeFile(filePath,options)
        return bitmap
}

Copy the code

The resulting image is half the original

conclusion

For image compression, first you can change the image format to RGB_565, reduce half of such images and then for image display can use sampling rate compression or zoom compression to we display the way to the resolution of the image size, if is to change the image upload server so you can use the quality compression way, However, this method does not support PNG images.

If you think this article is good, give it a thumbs up and a pat on the back (o^^o).

Support original, if you need to reprint please indicate the address of this article, thank you!