• preface
• RGB is introduced
• Image memory calculation
• Read bitmap size and type
• If a ‘500*500’ PNG ‘hd image is loaded in memory. How much memory should it take up?
• If the image is a local source image, is it still 0.95MB?
• Bitmap compression
• The compression principle
• Space occupied by compressed Bitmap disks
• Compress the memory occupied by Bitmap
• Use inSampleSize for compression
• Use createScaledBitmap or Matrix
• BitmapFactory. Options three-piece suit
• Bitmap local decoding

RGB color model: The most common color model, device dependent. R, G, and B represent the red, green, and blue color channels respectively, and their values are [0,255].

RGB 8-bit color: indicates the use of 8-bit (bit) color, a total of 2^8 = 128 colors. Analogously RGB 16 bit color, RGB 24 bit color, RGB 32 bit color, the more bits you use, the more colors you can represent, the number of 24 bits of color has been a lot, called “true color”.

32 bits and 24 bits represent the same amount of color, one more transparency.

Android Bitmap uses three color formats:

• ALPHA_8 – Each pixel is 1 byte and stores transparency information, no color information.
• RGB_565 — Each pixel contains 2 bytes of color information, R 5 bits, G 6 bits, and B 5 bits, representing 2^16 colors.
• ARGB_8888-4 bytes per pixel for color information, 1 byte each for 2^24 colors, and 1 byte for transparency information.

The BitmapFactory class provides several decoding methods for creating bitmaps from various sources (decodeByteArray(), decodeFile(), decodeResource(), and so on). Choose the most appropriate decoding method based on your image data source. These methods attempt to allocate memory for the constructed bitmap and can easily cause OutOfMemory exceptions. Each type of decoding method has an additional signature that allows you to specify decoding Options through the BitmapFactory.options class. Setting the inJustDecodeBounds property to True at decode time avoids memory allocation, returns null for bitmap objects, but sets outWidth, outHeight, and outMimeType. This method lets you read the size and type of the image data before constructing a bitmap and allocating memory for it.

BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeResource(getResources(), R.id.myimage, options);
int imageHeight = options.outHeight;
int imageWidth = options.outWidth;
String imageType = options.outMimeType;
Copy the code

To avoid java.lang.OutOfMemory exceptions, check the size of the bitmap before decoding it, unless you absolutely trust the source to provide you with predictable image data that can easily fit into the available memory.

To start with, let’s take a look at some of the basics:

To provide good graphics quality on devices with different pixel densities, you should provide multiple versions of each bitmap in your application (one version for each density level) at the appropriate resolution. Otherwise, the Android system must scale the bitmap so that it takes up the same amount of visible space on each screen, leading to scaling distortions such as blurring.

For example, if you have a graphable bitmap resource that has a size of 48×48 pixels on a medium-density screen, it should have a size of 48×48 pixels on a screen of various other densities:

• 36×36 (0.75x) – Low density (LDPI)
• 48×48 (1.0x baseline) – Medium density (MDPI)
• 72×72 (1.5x) – High density (HDPI)
• 96×96 (2.0x) – Ultra High Density (XHDPI)
• 144×144 (3.0x) – Ultra High Density (XXHDPI)
• 192×192 (4.0x) – Ultra Ultra High Density (XXXHDPI)

Then, place the generated image file in the appropriate subdirectory under RES /, and the system will automatically select the correct file according to the pixel density of the device running the application. Later, each time you reference @drawable/ XXX, the system selects the appropriate bitmap based on the DPI of the screen. If you do not provide a density-specific resource for a density, the system selects the next best match and scales it to fit the screen.

Measurement: 1520 x 2688 size 334.28KB picture, screen density of 480 mobile phone;

• On thedrawable-xxdpiThe loaded into theBitmapThe memory occupied by is16343040 (1520 * 2688 * 4)Since the image does not need to be scaled, it only needs to be computedARGB_8888The number of bytes occupied is fine;
• On thedrawable-mdpiThe loaded into theBitmapThe memory occupied by is147087360 (1520 * 3 * 2688 * 3 * 4)Because themdip 到 xxdpiThe width and height of the image will be enlarged by 4 times;

Resources in the nodpi directory are treated as density-independent and will not be scaled.

Image compression is a very common development scenario in Android. There are two main compression methods: one is down-sampling compression and the other is quality compression.

• The former is to reduce the image size, change the image storage volume;
• The latter achieves the same goal by losing color accuracy without changing the image size.

Image size is actually modified by modifying the number of pixels, the process of amplification is called up sampling, the process of reduction is called down sampling.

To know how to compress the Bitmap to reduce the memory footprint, you need to know how to calculate the memory footprint of the Bitmap. Calculating the memory footprint of an image is explained in detail in this article.

Bitmap bitmap = BitmapFactory.decodeFile("/sdcard/test.png"); Bitmap compress = Bitmap.createScaledBitmap(bitmap, bitmap.getWidth()/2, bitmap.getHeight()/2, true); // Or use matrix directly to scale, View Bitmap. CreateScaledBitmap source code is the use of matrix zooming Bitmap Bitmap. = BitmapFactory decodeFile ("/sdcard/test. The PNG "); Matrix matrix = new Matrix(); Matrix. SetScale (0.5 0.5 f, f); bm = Bitmap.createBitmap(bitmap, 0, 0, bit.getWidth(), bit.getHeight(), matrix, true);Copy the code

Bilinear Resampling is adopted in this way. Unlike neighboring sampling algorithm, which directly and rudely selects a pixel, this algorithm refers to the value of 2×2 points around the corresponding position of the source pixel and takes corresponding weight according to the relative position. After calculation, the target image is obtained.

Different sampling algorithms will produce different effects. In addition to the two commonly used sampling algorithms in Android, there are also more common ones, such as Bicubic Resampling and Lanczos Resampling. If you are not satisfied with the results of the two sampling algorithms used by Android, you can introduce other algorithms if necessary.

BitmapRegionDecoder can be used to decode rectangular regions in an image. BitmapRegionDecoder is especially useful when the original image is large and only part of the image is needed. To create a BitmapRegionDecoder, call newInstance(). Given a BitmapRegionDecoder, the user can call encodeRegio() repeatedly to get the decoded Bitmap of the specified region.

try {
    inputStream = getResources().getAssets().open("qq.jpg");
    BitmapRegionDecoder mRegionDecoder = BitmapRegionDecoder.newInstance(inputStream, false);
    BitmapFactory.Options sOptions = new BitmapFactory.Options();
    sOptions.inPreferredConfig = Bitmap.Config.ARGB_8888;
    sOptions.inSampleSize = 2;
    Rect mRect = new Rect();
    mRect.top = 0;
    mRect.left = 0;
    mRect.right = 100;
    mRect.bottom = 100;
    Bitmap bitmap = mRegionDecoder.decodeRegion(mRect, sOptions);
    //bitmap.getByteCount()=40000
} catch (IOException e) {
    e.printStackTrace();
}
Copy the code

Note that the width and height of the mRect cannot be too large. Otherwise, an OOM error will occur when loading the Bitmap.