如何前进到字节流中包含的压缩字节序列？

我有一个字节流，它是多个部分的串联，其中每个部分都由一个标头和一个紧缩的字节流组成。

我需要拆分此字节流部分，但标头仅包含有关未压缩形式的数据的信息，没有有关压缩数据长度的提示，因此我可以在流中正确前进并解析下一部分。

到目前为止，我发现超越压缩字节序列的唯一方法是根据本规格 http://www.ietf.org/rfc/rfc1951.txt。根据我通过阅读规范的理解，deflate 流由块组成，这些块可以是压缩块或文字块。

文字块包含一个大小标头，可用于轻松超越它。

压缩块由“前缀码”组成，这些“前缀码”是可变长度的位序列，对 deflate 算法具有特殊含义。由于我只对找出压缩的流长度感兴趣，因此我想我需要查找的唯一代码是“0000000”，根据规范，它表示块的结束。

所以我想出了这个 CoffeeScript 函数来解析 deflate 流（我正在处理 Node.js）

# The job of this function is to return the position
# after the deflate stream contained in 'buffer'. The
# deflated stream begins at 'pos'.
advanceDeflateStream = (buffer, pos) ->
  byteOffset = 0
  finalBlock = false
  while 1
    if byteOffset == 6
      firstTypeBit = 0b00000001 & buffer[pos]
      pos++
      secondTypeBit = 0b10000000 & buffer[pos]
      type = firstTypeBit | (secondTypeBit << 1)
    else
      if byteOffset == 7
        pos++
      type = buffer[pos] & (0b01100000 >>> byteOffset)
    if type == 0
      # Literal block
      # ignore the remaining bits and advance position
      byteOffset = 0
      pos++
      len = buffer.readUInt16LE(pos)
      pos += 2
      lenComplement = buffer.readUInt16LE(pos)
      if (len ^ ~lenComplement)
        throw new Error('Literal block lengh check fail')
      pos += (2 + len) # Advance past literal block
    else if type in [1, 2]
      # huffman block
      # we are only interested in finding the 'block end' marker
      # which is signaled by the bit string 0000000 (256)
      eob = false
      matchedZeros = 0
      while !eob
        byte = buffer[pos]
        for i in [byteOffset..7]
          # loop the remaining bits looking for 7 consecutive zeros
          if (byte ^ (0b10000000 >>> byteOffset)) >>> (7 - byteOffset)
            matchedZeros++
          else
            # reset counter
            matchedZeros = 0
          if matchedZeros == 7
            eob = true
            break
          byteOffset++
        if !eob
          byteOffset = 0
          pos++
    else
      throw new Error('Invalid deflate block')
    finalBlock = buffer[pos] & (0b10000000 >>> byteOffset)
    if finalBlock
      break
  return pos

为了检查这是否有效，我编写了一个简单的摩卡测试用例：

zlib = require 'zlib'

test 'sample deflate stream', (done) ->
  data = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' # length 30   
  zlib.deflate data, (err, deflated) ->
    # deflated.length == 11
    advanceDeflateStream(deflated, 0).shoudl.eql(11)
    done()

问题是这个测试失败了，我不知道如何调试它。我接受任何指出我在解析算法中遗漏的内容或包含任何语言的上述函数的正确版本的答案。

找到 deflate 流甚至 deflate 块末尾的唯一方法是解码其中包含的所有霍夫曼代码。您可以搜索的所有位模式都不会出现在流的较早位置。