compact index是EROFS默认使用的压缩布局，内核提交描述如下：

staging: erofs: add compacted ondisk compression indexes

This patch introduces new compacted compression indexes.

In contract to legacy compression indexes that
   each 4k logical cluster has an 8-byte index,
compacted ondisk compression indexes will have
   amortized 2 bytes for each 4k logical cluster (compacted 2B)
   amortized 4 bytes for each 4k logical cluster (compacted 4B)

In detail, several continuous clusters will be encoded in
a compacted pack with cluster types, offsets, and one blkaddr
at the end of the pack to leave 4-byte margin for better
decoding performance, as illustrated below:
   _____________________________________________
  |___@_____ encoded bits __________|_ blkaddr _|
  0       .                                     amortized * vcnt
  .          .
  .             .                   amortized * vcnt - 4
  .                .
  .___________________.
  |_type_|_clusterofs_|

Note that compacted 2 / 4B should be aligned with 32 / 8 bytes
in order to avoid each pack crossing page boundary.

以下分析参考erofs-utils 1.3。

legacy compression的index是8个字节，对应一个4KB的lcluster:

struct z_erofs_vle_decompressed_index {
	__le16 di_advise;
	/* where to decompress in the head cluster */
	__le16 di_clusterofs;

	union {
		/* for the head cluster */
		__le32 blkaddr;
		/*
		 * for the rest clusters
		 * eg. for 4k page-sized cluster, maximum 4K*64k = 256M)
		 * [0] - pointing to the head cluster
		 * [1] - pointing to the tail cluster
		 */
		__le16 delta[2];
	} di_u;
};

一个文件的块index的大小indexsize：

static unsigned int vle_compressmeta_capacity(erofs_off_t filesize)
{
	const unsigned int indexsize = BLK_ROUND_UP(filesize) *
		sizeof(struct z_erofs_vle_decompressed_index);

	return Z_EROFS_LEGACY_MAP_HEADER_SIZE + indexsize;
}

Z_EROFS_LEGACY_MAP_HEADER_SIZE:

struct z_erofs_map_header {
	__le32	h_reserved1;
	__le16	h_advise;
	/*
	 * bit 0-3 : algorithm type of head 1 (logical cluster type 01);
	 * bit 4-7 : algorithm type of head 2 (logical cluster type 11).
	 */
	__u8	h_algorithmtype;
	/*
	 * bit 0-2 : logical cluster bits - 12, e.g. 0 for 4096;
	 * bit 3-7 : reserved.
	 */
	__u8	h_clusterbits;
};

#define Z_EROFS_VLE_LEGACY_HEADER_PADDING       8

#define Z_EROFS_LEGACY_MAP_HEADER_SIZE	\
	(sizeof(struct z_erofs_map_header) + Z_EROFS_VLE_LEGACY_HEADER_PADDING)

在写压缩文件时：

u8 *compressmeta = malloc(vle_compressmeta_capacity(inode->i_size));
if (!compressmeta)
	return -ENOMEM;

注意到z_erofs_map_header也占用8Bytes。也就是如下布局图：

             +----legacymetasize/extent_isize-------+
             |                                      |
+------------+            index start         index end
|inode|xattrs|                |                     |
+------------|---------+------|-----+-----+----+----|
             | map hdr | pad  | 8B  | 8B  | ...|last|
             |---------+------+-----+-----+----+----|
             |                |                     |
       compressmeta       metacur(1st)         metacur(last)
             |                |
             +-LEGACY MAP HDR-+

ok，我们来看compact index，在z_erofs_convert_to_compacted_format():

const unsigned int mpos = Z_EROFS_VLE_EXTENT_ALIGN(inode->inode_isize +
						   inode->xattr_isize) +
			  sizeof(struct z_erofs_map_header);

留意到cluster type只有3种：

enum {
	Z_EROFS_VLE_CLUSTER_TYPE_PLAIN		= 0,
	Z_EROFS_VLE_CLUSTER_TYPE_HEAD		= 1,
	Z_EROFS_VLE_CLUSTER_TYPE_NONHEAD	= 2,
	Z_EROFS_VLE_CLUSTER_TYPE_RESERVED	= 3,
	Z_EROFS_VLE_CLUSTER_TYPE_MAX
};

用2个bits就可以了：

#define Z_EROFS_VLE_DI_CLUSTER_TYPE_BITS        2

而di_clusterofs有效数据只要12bits即可，也就是说type + clusterofs/delta，14bits就可以搞定，也就是compact 2B。

if (destsize == 4) {
        vcnt = 2;
} else if (destsize == 2 && logical_clusterbits == 12) {
        vcnt = 16;
} else {
        return ERR_PTR(-EINVAL);
}
encodebits = (vcnt * destsize * 8 - 32) / vcnt;

对compact 2b，encodebits是(16x2Bx8-32)/16=14 bits, 对齐 32bits。

                            in
         8B align            |
------------|---------+------|-----+-----+----+----|
            | map hdr | pad  | 8B  | 8B  | ...|last|
            |---------|------+-----+-----+----+----|
                      |
                      mpos

因为compact 2b需要32bits对齐，如果mpos没有32bits对齐，那就要补上就有了compact_4b_initial。

compacted_4b_initial = (32 - mpos % 32) / 4;

then，算下2b有多少：

compacted_2b = rounddown(totalidx - compacted_4b_initial, 16);

剩下的就是compacted_4b_end:

compacted_4b_end = totalidx - compacted_4b_initial - compacted_2b;

来看out的生成：

type + offset的14bits分成了1个字节和6bits，so rem就是6，那剩下的2bits需要从next获取，然后拼接：

ch = out[pos / 8] & ((1 << rem) - 1);
out[pos / 8] = (v << rem) | ch;

因为2bits被用了，那剩下的放到下一个字节，也就是:

out[pos / 8 + 1] = v >> (8 - rem);

在此基础上再右移8bits得到下一个，也就是:

out[pos / 8 + 2] = v >> (16 - rem);

Done.