反序列bit

#include <stdio.h>
#include
#include

// 定义描述反序列化信息的结构体
typedef struct {
const uint32_t *data; // 数据数组
int num_elements; // 数据数组的元素数量
int bit_position; // 当前位偏移量（以位为单位）
} DeserializationContext;

// 从指定的反序列化上下文中按位反序列化指定长度的无符号8位整数，并返回结果
uint8_t deserialize_uint8(DeserializationContext *ctx, int num_bits) {
uint8_t result = 0;
int remaining_bits = num_bits;

while (remaining_bits > 0) {
    // 当前位置所在的数组元素索引
    int current_word = ctx->bit_position / 32;
    // 当前位置在数组元素中的位偏移
    int start_bit_in_word = ctx->bit_position % 32;

    // 当前数组元素中可用的位数
    int available_bits_in_word = 32 - start_bit_in_word;
    // 需要从当前数组元素中提取的位数
    int bits_to_copy = (remaining_bits < available_bits_in_word) ? remaining_bits : available_bits_in_word;

    // 从当前数组元素中提取指定位数的数据，并合并到结果中
    uint32_t word = ctx->data[current_word];
    uint32_t extracted_bits = (word >> start_bit_in_word) & ((1 << bits_to_copy) - 1);
    result |= (extracted_bits << (num_bits - remaining_bits));

    // 更新剩余需要提取的位数和当前位偏移量
    remaining_bits -= bits_to_copy;
    ctx->bit_position += bits_to_copy;

    // 如果剩余位数大于当前数组元素可用位数，切换到下一个数组元素
    if (remaining_bits > 0 && bits_to_copy == available_bits_in_word) {
        ctx->bit_position += start_bit_in_word;  // 跳过当前数组元素剩余位数
    }
}

return result;
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

}

// 从指定的反序列化上下文中按位反序列化指定长度的有符号8位整数，并返回结果
int8_t deserialize_int8(DeserializationContext *ctx, int num_bits) {
// 反序列化无符号8位整数
uint8_t unsigned_value = deserialize_uint8(ctx, num_bits);

// 对有符号整数进行符号扩展
int8_t signed_value;
if (unsigned_value & (1 << (num_bits - 1))) {
    // 负数的补码表示，进行符号扩展
    signed_value = (int8_t)(unsigned_value | (~((1 << num_bits) - 1)));
} else {
    // 正数或零的补码表示
    signed_value = (int8_t)unsigned_value;
}

return signed_value;
1
2
3
4
5
6
7
8
9
10
11

}

// 以下是反序列化其他位数和数据类型的函数，使用类似的方法实现：

uint16_t deserialize_uint16(DeserializationContext *ctx, int num_bits) {
uint16_t result = 0;
int remaining_bits = num_bits;

while (remaining_bits > 0) {
    // 实现方法类似，直接调用 deserialize_uint8 函数
    result |= (uint16_t)deserialize_uint8(ctx, remaining_bits) << (num_bits - remaining_bits);
    remaining_bits -= 8; // 每次处理8位
}

return result;
1
2
3
4
5
6
7

}

int16_t deserialize_int16(DeserializationContext *ctx, int num_bits) {
// 实现方法类似，直接调用 deserialize_int8 函数
return (int16_t)deserialize_int8(ctx, num_bits);
}

uint32_t deserialize_uint32(DeserializationContext *ctx, int num_bits) {
uint32_t result = 0;
int remaining_bits = num_bits;

while (remaining_bits > 0) {
    // 实现方法类似，直接调用 deserialize_uint8 函数
    result |= (uint32_t)deserialize_uint8(ctx, remaining_bits) << (num_bits - remaining_bits);
    remaining_bits -= 8; // 每次处理8位
}

return result;
1
2
3
4
5
6
7

}

int32_t deserialize_int32(DeserializationContext *ctx, int num_bits) {
// 实现方法类似，直接调用 deserialize_int8 函数
return (int32_t)deserialize_int8(ctx, num_bits);
}

uint64_t deserialize_uint64(DeserializationContext *ctx, int num_bits) {
uint64_t result = 0;
int remaining_bits = num_bits;

while (remaining_bits > 0) {
    // 实现方法类似，直接调用 deserialize_uint8 函数
    result |= (uint64_t)deserialize_uint8(ctx, remaining_bits) << (num_bits - remaining_bits);
    remaining_bits -= 8; // 每次处理8位
}

return result;
1
2
3
4
5
6
7

}

int64_t deserialize_int64(DeserializationContext *ctx, int num_bits) {
// 实现方法类似，直接调用 deserialize_int8 函数
return (int64_t)deserialize_int8(ctx, num_bits);
}

int main() {
// 示例 uint32_t 数组（假设包含待反序列化的数据）
const uint32_t data[] = {0xABCD5678, 0x12345678}; // 假设数据数组

// 创建
1