微信32Kb图片压缩方案[微信]

于杭州尚妆 |

网络上关于如何针对图片进行有效合理的压缩其实已经有很多成熟的解决方案了，我这里要说的是针对微信 32KB 限制的压缩方案，这也是在 SocialSdkLibrary 中采用的，经过了很多细节的测试，当然这可能不是最好的方法，欢迎一起讨论。

假如希望得到一个大小为 maxSize 大小的图片，整个压缩过程分为如下几个步骤：

  • 获取图片的宽高，这个很简单使用 options.inJustDecodeBounds 可以实现。
  • 利用 bitmap 的宽高，通过 w*h < maxSize 为标准大致计算目标图片宽高，这里的计算是不精确的
  • 使用近似的目标宽高 decode 目标图片，经过此步之后拿到的 bitmap 会稍微大于 maxSize。
  • 细节调整，利用 matrix.scale 每次缩小为原来的 0.9，循环逼近目标大小。

计算原始宽高

这里就是最基本的方法，但是因为流程的完整，还是记录下。

1
2
3
4
5
6
7
8
9
10
11
public static Size getBitmapSize(String filePath) {
    // 仅获取宽高
    BitmapFactory.Options options = new BitmapFactory.Options();
    // 该属性设置为 true 只会加载图片的边框进来，并不会加载图片具体的像素点
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeFile(filePath, options);
    // 获得原图的宽和高
    int outWidth = options.outWidth;
    int outHeight = options.outHeight;
    return new Size(outWidth, outHeight);
}

计算近似宽高

首先说一下为什么要有这一步：

  • 为了尽量少的占用内存，我们获取的图片只是用来在打开微信时展现一个缩略图，而实际的图片大小是无法预估的，不能盲目拿到内存中，因此我们要先计算一个大致的尺寸；
  • 最后一步中，我们将会采用循环压缩的方式逼近目标大小，先进行这步压缩，也是为了减少最后循环的次数；

这一步骤的目标就是获取到一个稍微大于 32KB 的图片，后面再进行细节微调。

那么接下来如何计算一个合适的宽高，我们简单的这样约束 32kb = w * h，虽然这样并不完全合理，因为最终 byte[] 的长度和宽高并没有绝对的关系，不过之前也说过了，这步是不精确的，目标是一个大于稍微 32KB 的 bitmap;

于是可以得到如下关系，为了好理解，就用汉字标识：

1
2
3
4
5
比例(>1) = 较长边 / 较短边
32KB = 较短边 * 较长边
32KB = 较短边 * 较短边 * 比例(>1)
较短边 = sqrt(maxSize/比例(>1))
较长边 = 较短边 * 比例(>1)

经过上面的关系，可以按照比例计算出 较短边 和 较长边，代码如下，简单看下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/**
 * 根据kb计算缩放后的大约宽高
 *
 * @param originSize  图片原始宽高
 * @param maxSize byte length 
 * @return 大小
 */
private static Size calculateSize(Size originSize, int maxSize) {
    int bw = originSize.width;
    int bh = originSize.height;
    Size size = new Size();
    // 如果本身已经小于，就直接返回
    if (bw * bh <= maxSize) {
        size.width = bw;
        size.height = bh;
        return size;
    }
    // 拿到大于1的宽高比
    boolean isHeightLong = true;
    float bitRatio = bh * 1f / bw;
    if (bitRatio < 1) {
        bitRatio = bw * 1f / bh;
        isHeightLong = false;
    }
    // 较长边 = 较短边 * 比例(>1)
    // maxSize = 较短边 * 较长边 = 较短边 * 较短边 * 比例(>1)
    // 由此计算短边应该为 较短边 = sqrt(maxSize/比例(>1))
    int thumbShort = (int) Math.sqrt(maxSize / bitRatio);
    // 较长边 = 较短边 * 比例(>1)
    int thumbLong = (int) (thumbShort * bitRatio);
    if (isHeightLong) {
        size.height = thumbLong;
        size.width = thumbShort;
    } else {
        size.width = thumbLong;
        size.height = thumbShort;
    }
    return size;
}

第一次采样获取目标图片

拿到目标尺寸之后，根据目标尺寸和原始图片尺寸，计算对应的 inSimpleSize，对图片进行第一次的 decode。

同样因为这一步不是一个那么精确的操作，因此对于大小比较小的图片（这里定的是 400*400）就不进行压缩了，怕压的太厉害，其他的就是按照常规的采样获取到一个 bitmap;

需要注意的是由于图片大小和图片尺寸没有绝对的关系，所以要给一个更高的上限，我们在调用 calculateSize() 使用的不是 32KB，而是用了他的 5 倍，这样可以保证图片最终稍微大于 32KB;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
 * 使用 path decode 出来一个差不多大小的，此时因为图片质量的关系，可能大于kbNum
 *
 * @param filePath path
 * @param maxSize  byte
 * @return bitmap
 */
public static Bitmap getMaxSizeBitmap(String filePath, int maxSize) {
    Size originSize = getBitmapSize(filePath);
    int sampleSize = 0;
    // 我们对较小的图片不进行采样，因为采样只是尽量接近 32k 和避免占用大量内存
    // 对较小图片进行采样会导致图片更模糊，所以对不大的图片，直接走后面的细节调整
    if (originSize.height * originSize.width < 400 * 400) {
        sampleSize = 1;
    } else {
        Size size = calculateSize(originSize, maxSize * 5);
        while (sampleSize == 0 
                || originSize.height / sampleSize > size.height 
                || originSize.width / sampleSize > size.width) {
            sampleSize += 2;
        }
    }
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = false;
    options.inSampleSize = sampleSize;
    options.inMutable = true;
    Bitmap bitmap = BitmapFactory.decodeFile(filePath, options);
    LogUtils.e(TAG, "sample size = " + sampleSize + "  bitmap大小 = " + bitmap.getByteCount());
    return bitmap;
}

循环逼近目标大小

此时我们拿到了一个大小稍微大于 32KB 的 bitmap，接下来需要循环压缩该 bitmap 使最终得到 byte[] 小于 32KB;

这里使用 Matrix 的 setScale() 方法，每次将图片缩小为原来的 0.9，并且不断检测大小，直到达到标准。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public static byte[] getStaticSizeBitmapByteByBitmap(Bitmap srcBitmap, int maxSize, Bitmap.CompressFormat
    // 首先进行一次大范围的压缩
    Bitmap tempBitmap;
    ByteArrayOutputStream output = new ByteArrayOutputStream();
    // 设置矩阵数据
    Matrix matrix = new Matrix();
    srcBitmap.compress(format, 100, output);
    // 如果进行了上面的压缩后，依旧大于32K，就进行小范围的微调压缩
    byte[] bytes = output.toByteArray();
    LogUtils.e(TAG, "压缩之前 = " + bytes.length);
    while (bytes.length > maxSize) {
        matrix.setScale(0.9f, 0.9f);//每次缩小 1/10
        tempBitmap = srcBitmap;
        srcBitmap = Bitmap.createBitmap(
                tempBitmap, 0, 0,
                tempBitmap.getWidth(), tempBitmap.getHeight(), matrix, true);
        recyclerBitmaps(tempBitmap);
        output.reset();
        srcBitmap.compress(format, 100, output);
        bytes = output.toByteArray();
        LogUtils.e(TAG, "压缩一次 = " + bytes.length);
    }
    LogUtils.e(TAG, "压缩后的图片输出大小 = " + bytes.length);
    recyclerBitmaps(srcBitmap);
    return bytes;
}

最后

测试图片压缩的结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
测试图片大小 14.58M
	原始图片大小 = 8000 * 4160
	目标图片大小 = 559 * 291
	sample size = 16 采样后 bitmap大小 = 520000
	开始循环压缩之前 bytes = 143255
	压缩一次 bytes = 110424
	压缩一次 bytes = 86231
	压缩一次 bytes = 66464
	压缩一次 bytes = 53433
	压缩一次 bytes = 42418
	压缩一次 bytes = 34061
	压缩一次 bytes = 26745
	压缩后的图片输出大小 bytes = 26745

测试图片大小 388.16KB
	原始图片大小 = 479 * 850
	目标图片大小 = 303 * 537
	sample size = 2 采样后 bitmap大小 = 406300
	开始循环压缩之前 bytes = 56926
	压缩一次 bytes = 47832
	压缩一次 bytes = 39200
	压缩一次 bytes = 31752
	压缩后的图片输出大小 bytes = 31752

测试图片为 2.39M
	原始图片大小 = 2160 * 3840
	目标图片大小 = 303 * 538
	sample size = 8 采样后 bitmap大小 = 518400
	开始循环压缩之前 bytes = 92282
	压缩一次 bytes = 73441
	压缩一次 bytes = 58790
	压缩一次 bytes = 47730
	压缩一次 bytes = 39083
	压缩一次 bytes = 31457
	压缩后的图片输出大小 bytes = 31457

可以看到当图片很大时，会造成压缩次数过多，而且出来的图片被压缩的更厉害，而平常更常见的网络图（通常几百K）拍摄图（通常2-4M）可以达到不错的压缩效果。

------ 本文结束 🎉🎉 谢谢观看  ------