在swift中读取任意位数的方法

Question

我正在尝试在swift中进行一些二进制文件解析,虽然我有事情工作但我有一个情况,我有可变字段.

我的所有解析都在默认情况下工作

我抢了

1-bit field
1-bit field
1-bit field
11-bits field
1-bit field
(optional) 4-bit field
(optional) 4-bit field
1-bit field
2-bit field
(optional) 4-bit field
5-bit field
6-bit field
(optional) 6-bit field
(optional) 24-bit field
(junk data - up until byte buffer 0 - 7 bits as needed)

大多数数据只使用一组选项,所以我已经开始编写类来处理这些数据.我的一般方法是创建一个指针结构,然后从中构造一个字节数组:

let rawData: NSMutableData = NSMutableData(data: input_nsdata)
var ptr: UnsafeMutablePointer<UInt8> = UnsafeMutablePointer<UInt8(rawData.mutableBytes)
bytes = UnsafeMutableBufferPointer<UInt8>(start: ptr, count: rawData.length - offset)

所以我最终使用了一个数组,[UInt8]我可以用类似于以下的方式进行解析:

let b1 = (bytes[3] & 0x01) << 5
let b2 = (bytes[4] & 0xF8) >> 3
  return Int(b1 | b2)

因此,我遇到麻烦的地方是可选字段,因为我的数据并不特别在字节边界上,所有内容都变得复杂.在理想的世界中,我可能只是直接使用指针并根据需要按字节前进,但是,我无法通过3位推进指针 - 这让我想到了我的问题

处理我的情况的最佳方法是什么？

我想到的一个想法是提出反映可选字段的各种结构,除了我不确定如何创建位对齐的打包结构.

我最好的方法是什么？为了澄清 - 初始1-bit字段确定设置了哪个可选字段.

Answer 1

如果这些字段不在字节边界上，那么您必须跟踪当前字节和字节内的当前位位置。

这是一个可能的解决方案，它允许从数据数组中读取任意数量的位并完成所有簿记。唯一的限制是 的结果nextBits()必须适合UInt (32 或 64 位，具体取决于平台)。

struct BitReader {

    private let data : [UInt8]
    private var byteOffset : Int
    private var bitOffset : Int

    init(data : [UInt8]) {
        self.data = data
        self.byteOffset = 0
        self.bitOffset = 0
    }

    func remainingBits() -> Int {
        return 8 * (data.count - byteOffset) - bitOffset
    }

    mutating func nextBits(numBits : Int) -> UInt {
        precondition(numBits <= remainingBits(), "attempt to read more bits than available")

        var bits = numBits     // remaining bits to read
        var result : UInt = 0  // result accumulator

        // Read remaining bits from current byte:
        if bitOffset > 0 {
            if bitOffset + bits < 8 {
                result = (UInt(data[byteOffset]) & UInt(0xFF >> bitOffset)) >> UInt(8 - bitOffset - bits)
                bitOffset += bits
                return result
            } else {
                result = UInt(data[byteOffset]) & UInt(0xFF >> bitOffset)
                bits = bits - (8 - bitOffset)
                bitOffset = 0
                byteOffset = byteOffset + 1
            }
        }

        // Read entire bytes:
        while bits >= 8 {
            result = (result << UInt(8)) + UInt(data[byteOffset])
            byteOffset = byteOffset + 1
            bits = bits - 8
        }

        // Read remaining bits:
        if bits > 0 {
            result = (result << UInt(bits)) + (UInt(data[byteOffset]) >> UInt(8 - bits))
            bitOffset = bits
        }

        return result
    }
}

用法示例：

let data : [UInt8] = ... your data ...
var bitReader = BitReader(data: data)

let b1 = bitReader.nextBits(1)
let b2 = bitReader.nextBits(1)
let b3 = bitReader.nextBits(1)
let b4 = bitReader.nextBits(11)
let b5 = bitReader.nextBits(1)
if b1 > 0 {
    let b6 = bitReader.nextBits(4)
    let b7 = bitReader.nextBits(4)
}
// ... and so on ...

这是另一种可能的实现，它更简单，也许更有效。它将字节收集到 中UInt，然后一步提取结果。这里的限制是numBits + 7必须小于或等于 an 中的位数UInt（32 或 64）。（当然UInt 可以替换为UInt64使其与平台无关。）

struct BitReader {
    private let data : [UInt8]
    private var byteOffset = 0
    private var currentValue : UInt = 0 // Bits which still have to be consumed 
    private var currentBits = 0         // Number of valid bits in `currentValue`

    init(data : [UInt8]) {
        self.data = data
    }

    func remainingBits() -> Int {
        return 8 * (data.count - byteOffset) + currentBits
    }

    mutating func nextBits(numBits : Int) -> UInt {
        precondition(numBits <= remainingBits(), "attempt to read more bits than available")

        // Collect bytes until we have enough bits:
        while currentBits < numBits {
            currentValue = (currentValue << 8) + UInt(data[byteOffset])
            currentBits = currentBits + 8
            byteOffset = byteOffset + 1
        }

        // Extract result:
        let remaining = currentBits - numBits
        let result = currentValue >> UInt(remaining)

        // Update remaining bits:
        currentValue = currentValue & UInt(1 << remaining - 1)
        currentBits = remaining
        return result
    }

}