Question

我有一个bytes对象或bytearray对象，表示11位整数的压缩流。（编辑：Stream是没有填充的11位大端整数。）

是否有一种合理有效的方法将其复制到16位整数流中？或者任何其他整数类型？

我知道ctypes支持位字段，但我不确定这对我是否有帮助。

我是否可以“滥用”标准库的某些部分，这些部分已经为其他目的进行了这样的小工作？

如果我不得不求助于cython，是否有一个可以处理可变比特长度的良好实现？即不仅是11位输入，还有12,13等？

编辑：基于PM2 Ring答案的纯Python解决方案

def unpackIntegers(data, num_points, bit_len):
    """Unpacks an array of integers of arbitrary bit-length into a 
    system-word aligned array of integers"""
    # TODO: deal with native integer types separately for speedups
    mask = (1 << bit_len) - 1

    unpacked_bit_len = 2 ** ceil(log(bit_len, 2))
    unpacked_byte_len = ceil(unpacked_bit_len / 8)
    unpacked_array = bytearray(num_points * unpacked_byte_len)
    unpacked = memoryview(unpacked_array).cast(
        FORMAT_CODES[unpacked_byte_len])

    num_blocks = num_points // 8 

    # Note: zipping generators is faster than calculating offsets 
    #       from a block count
    for idx1_start, idx1_stop, idx2_start, idx2_stop in zip(
            range(0, num_blocks*bit_len, bit_len),
            range(bit_len, (num_blocks+1)*bit_len, bit_len),
            range(7, num_points, 8),
            range(-1, num_points-8, 8),
            ):
        n = int.from_bytes(data[idx1_start:idx1_stop], 'big')
        for i in range(idx2_start, idx2_stop, -1):
            unpacked[i] = n & mask
            n >>= bit_len
    # process left-over part (missing from PM2 Ring's answer)
    else:
        points_left = num_points % 8 
        bits_left = points_left * bit_len
        bytes_left = len(data)-num_blocks*bit_len
        num_unused_bits = bytes_left * 8 - bits_left

        n = int.from_bytes(data[num_blocks*bit_len:], 'big')
        n >>= num_unused_bits
        for i in range(num_points-1, num_points-points_left-1, -1):
            unpacked[i] = n & mask
            n >>= bit_len
    return unpacked

Answer 1

使用第三方库可能有一种更有效的方法，但这是使用标准Python实现此目的的一种方法。

unpack生成器以块的data参数进行迭代，data可以是任何产生字节的迭代。要解压缩11位数据，我们读取11个字节的块，将这些字节组合成一个整数，然后我们将整数切成8个整数，因此每个部分将包含来自相应11个源位的数据。

def unpack(data, bitlen):
    mask = (1 << bitlen) - 1
    for chunk in zip(*[iter(data)] * bitlen):
        n = int.from_bytes(chunk, 'big')
        a = []
        for i in range(8):
            a.append(n & mask)
            n >>= bitlen
        yield from reversed(a)

# Test

# 0 to 23 in 11 bit integers, packed into bytes
data = bytes([
    0, 0, 4, 1, 0, 48, 8, 1, 64, 48, 7, 
    1, 0, 36, 5, 0, 176, 24, 3, 64, 112, 15, 
    2, 0, 68, 9, 1, 48, 40, 5, 64, 176, 23,
])

print(list(unpack(data, 11)))

<强>输出

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]

请注意，如果data不包含bitlen个字节的倍数，那么它将以部分块结尾，这将被忽略。

将包含11位整数的bytearray转换为16位整数数组

1 个答案: