反序列化bit高字节开始

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

// 定义描述反序列化信息的结构体
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 >> (available_bits_in_word - bits_to_copy)) & ((1 << bits_to_copy) - 1);
        result |= (uint8_t)(extracted_bits << (remaining_bits - bits_to_copy));

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

        // 如果当前数组元素的位偏移量达到了32位，则移动到下一个数组元素
        if (ctx->bit_position % 32 == 0 && ctx->bit_position < num_bits) {
            ctx->bit_position++; // 跳过数组元素之间的间隙
        }
    }

    return result;
}

// 从指定的反序列化上下文中按位反序列化指定长度的有符号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;
}

// 从指定的反序列化上下文中按位反序列化指定长度的无符号16位整数，并返回结果
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;
}

// 从指定的反序列化上下文中按位反序列化指定长度的有符号16位整数，并返回结果
int16_t deserialize_int16(DeserializationContext *ctx, int num_bits) {
    // 实现方法类似，直接调用 deserialize_int8 函数
    return (int16_t)deserialize_int8(ctx, num_bits);
}

// 从指定的反序列化上下文中按位反序列化指定长度的无符号32位整数，并返回结果
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;
}

// 从指定的反序列化上下文中按位反序列化指定长度的有符号32位整数，并返回结果
int32_t deserialize_int32(DeserializationContext *ctx, int num_bits) {
    // 实现方法类似，直接调用 deserialize_int8 函数
    return (int32_t)deserialize_int8(ctx, num_bits);
}

// 从指定的反序列化上下文中按位反序列化指定长度的无符号64位整数，并返回结果
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;
}

// 从指定的反序列化上下文中按位反序列化指定长度的有符号64位整数，并返回结果
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[] = {0x12345678};  // 假设数据数组

    // 创建
    DeserializationContext ctx = {
        .data = data,
        .num_elements = sizeof(data) / sizeof(data[0]),
        .bit_position = 0        
    };
    printf("%d\r\n", deserialize_uint8(&ctx, 3));
    printf("%d\r\n", deserialize_uint8(&ctx, 7));
    printf("%d\r\n", deserialize_uint16(&ctx, 15));
    printf("%d\r\n", deserialize_uint8(&ctx, 7));
    return 0;
}