对一组整型数组采用Simple8b压缩，使用纯C语言编写代码

以下是使用 Simple8b 压缩一组整型数组的 C 代码示例：

#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>

#define BLOCK_SIZE 1024 // 压缩块的大小

void encode_simple8b(uint32_t *in, uint32_t n, uint8_t *out) {
    uint32_t i = 0;
    while (i < n) {
        uint8_t header = 0;
        uint32_t block[BLOCK_SIZE];
        uint32_t block_size = 0;
        
        // 构建一个大小为 BLOCK_SIZE 的块
        while (block_size < BLOCK_SIZE && i < n) {
            block[block_size++] = in[i++];
        }
        
        // 编码 Simple8b 压缩块
        if (block_size >= 28) {
            // 28个元素以上使用 Simple8b 固定长度编码
            uint32_t data[8];
            for (int j = 0; j < 8; j++) {
                data[j] = block[j * 28];
            }
            header |= 0x80;
            for (int j = 0; j < 8; j++) {
                uint8_t value = 0;
                for (int k = 0; k < 28; k++) {
                    value |= ((block[j * 28 + k] - data[j]) << (4 * k));
                }
                out[1 + 4 * j] = value & 0xFF;
                out[2 + 4 * j] = (value >> 8) & 0xFF;
                out[3 + 4 * j] = (value >> 16) & 0xFF;
                out[4 + 4 * j] = (value >> 24) & 0xFF;
            }
            out[0] = header;
            out += 33;
        } else {
            // 27个元素以下使用 Simple8b 可变长度编码
            uint32_t data[4];
            for (int j = 0; j < 4; j++) {
                data[j] = block[j * 7];
            }
            header |= block_size << 3;
            for (int j = 0; j < block_size; j++) {
                uint8_t value = 0;
                for (int k = 0; k < 7; k++) {
                    if (j * 7 + k < block_size) {
                        value |= ((block[j * 7 + k] - data[j]) << (4 * k));
                    }
                }
                out[1 + 4 * j] = value & 0xFF;
                out[2 + 4 * j] = (value >> 8) & 0xFF;
                out[3 + 4 * j] = (value >> 16) & 0xFF;
                out[4 + 4 * j] = (value >> 24) & 0xFF;
            }
            out[0] = header;
            out += 1 + 4 * block_size;
        }
    }
}

void decode_simple8b(uint8_t *in, uint32_t n, uint32_t *out) {
    uint32_t i = 0;
    while (i < n) {
        uint8_t header = in[i++];
        if (header & 0x80) {
            // Simple8b 固定长度编码
            uint32_t data[8];
            for (int j = 0; j < 8; j++) {
                data[j] = ((uint32_t)in[i + 4 * j]) | ((uint32_t)in[i + 4 * j + 1] << 8) |
                          ((uint32_t)in[i + 4 * j + 2] << 16) | ((uint32_t)in[i + 4 * j + 3] << 24);
            }
            i += 33;
            for (int j = 0; j < 8; j++) {
                uint8_t value = header >> (j + 1);
                for (int k = 0; k < 28; k++) {
                    out[j * 28 + k] = (value & 0x0F) + data[j];
                    value >>= 4;
                }
            }
        } else {
            // Simple8b 可变长度编码
            uint32_t block_size = header >> 3;
            uint32_t data[4];
            for (int j = 0; j < 4; j++) {
                data[j] = ((uint32_t)in[i + 4 * j]) | ((uint32_t)in[i + 4 * j + 1] << 8) |
                          ((uint32_t)in[i + 4 * j + 2] << 16) | ((uint32_t)in[i + 4 * j + 3] << 24);
            }
            i += 1 + 4 * block_size;
            for (int j = 0; j < block_size; j++) {
                uint8_t value = ((uint8_t *)in)[i++];
                for (int k = 0; k < 7 && j * 7 + k < BLOCK_SIZE; k++) {
                    out[j * 7 + k] = (value & 0x0F) + data[j];
                    value >>= 4;
                }
            }
        }
    }
}

int main() {
    uint32_t data[] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
    uint8_t compressed[128];
    uint32_t decompressed[128];
    encode_simple8b(data, 10, compressed);
    decode_simple8b(compressed, sizeof(compressed), decompressed);
    
    for (int i = 0; i < 10; i++) {
        printf("%u ", decompressed[i]);
    }
    printf("\n");
    
    return 0;
}

这个示例程序将 `data` 数组中的 10 个元素使用 Simple8b 压缩后存储到 `compressed` 数组中，然后再将 `compressed` 数组解压缩到 `decompressed` 数组中。最后，程序输出 `decompressed` 数组的元素。这个示例程序中，我们使用了 Simple8b 固定长度编码和 Simple8b 可变长度编码，分别适用于块大小大于等于28和小于28的情况。