将多个zlib压缩数据流有效地连接到单个流中

Question

如果我有几个带有压缩zlib数据的二进制字符串，是否有办法有效地将它们组合成一个压缩字符串而不解压缩所有内容？

我现在要做的示例：

c1 = zlib.compress("The quick brown fox jumped over the lazy dog. ")
c2 = zlib.compress("We ride at dawn! ")
c = zlib.compress(zlib.decompress(c1)+zlib.decompress(c2)) # Warning: Inefficient!

d1 = zlib.decompress(c1)
d2 = zlib.decompress(c2)
d = zlib.decompress(c)

assert d1+d2 == d # This will pass!

我想要的例子：

c1 = zlib.compress("The quick brown fox jumped over the lazy dog. ")
c2 = zlib.compress("We ride at dawn! ")
c = magic_zlib_add(c1+c2) # Magical method of combining compressed streams

d1 = zlib.decompress(c1)
d2 = zlib.decompress(c2)
d = zlib.decompress(c)

assert d1+d2 == d # This should pass!

我对zlib和DEFLATE算法不太了解，所以从理论上讲这可能是完全不可能的。另外，我必须使用use zlib;因此我无法包装zlib并提出自己的协议，该协议透明地处理级联流。

注意：我真的不介意该解决方案在Python中不是很简单。我愿意编写一些C代码并在Python中使用ctypes。

Answer 1

由于您不介意使用C，因此可以先查看gzjoin的代码。

注意，gzjoin代码必须解压缩以查找合并时必须更改的部分，但不必重新压缩。这还不错，因为解压缩通常比压缩快。

Answer 2

除了gzjoin需要解压缩第一个deflate流之外，您还可以查看gzlog.h和gzlog.c，它们可以有效地将短字符串附加到gzip文件中，而不必每次都对deflate流进行解压缩。 （可以轻松地对其进行修改以对zlib包裹的deflate数据进行操作，而不是对gzip包裹的deflate数据进行操作。）如果您可以控制第一个deflate流的创建，则可以使用此方法。如果不创建第一个deflate流，则必须使用gzjoin的方法，该方法需要解压缩。

没有一种方法需要重新压缩。

Answer 3

我只是将@zorlak's comment转换为答案并添加一些代码，以便稍后找到。

如果可以控制流的初始压缩，则可以将未压缩数据的长度，其Adler-32校验和以及压缩数据存储在某处。稍后，您可以按任意顺序连接各个流。

[请注意，由于concatenate函数会剥离除第一个流以外的所有流的zlib标头，因此我不确定各个流是否可以具有不同的压缩级别，压缩策略或窗口大小...

from typing import Tuple
import zlib


def prepare(data: bytes) -> Tuple[int, bytes, int]:
    deflate = zlib.compressobj()
    result = deflate.compress(data)
    result += deflate.flush(zlib.Z_SYNC_FLUSH)
    return len(data), result, zlib.adler32(data)


def concatenate(*chunks: Tuple[int, bytes, int]) -> bytes:
    if not chunks:
        return b''
    _, result, final_checksum = chunks[0]
    for length, chunk, checksum in chunks[1:]:
        result += chunk[2:]  # strip the zlib header
        final_checksum = adler32_combine(final_checksum, checksum, length)
    result += b'\x03\x00'  # insert a final empty block
    result += final_checksum.to_bytes(4, byteorder='big')
    return result


def adler32_combine(adler1: int, adler2: int, length2: int) -> int:
    # Python implementation of adler32_combine
    # The orignal C implementation is Copyright (C) 1995-2011, 2016 Mark Adler
    # see https://github.com/madler/zlib/blob/master/adler32.c#L143
    BASE = 65521
    WORD = 0xffff
    DWORD = 0xffffffff
    if adler1 < 0 or adler1 > DWORD:
        raise ValueError('adler1 must be between 0 and 2^32')
    if adler2 < 0 or adler2 > DWORD:
        raise ValueError('adler2 must be between 0 and 2^32')
    if length2 < 0:
        raise ValueError('length2 must not be negative')

    remainder = length2 % BASE
    sum1 = adler1 & WORD
    sum2 = (remainder * sum1) % BASE
    sum1 += (adler2 & WORD) + BASE - 1
    sum2 += ((adler1 >> 16) & WORD) + ((adler2 >> 16) & WORD) + BASE - remainder
    if sum1 >= BASE:
        sum1 -= BASE
    if sum1 >= BASE:
        sum1 -= BASE
    if sum2 >= (BASE << 1):
        sum2 -= (BASE << 1)
    if sum2 >= BASE:
        sum2 -= BASE

    return (sum1 | (sum2 << 16))

一个简单的例子：

hello = prepare(b'Hello World! ')
test = prepare(b'This is a test. ')
fox = prepare(b'The quick brown fox jumped over the lazy dog. ')
dawn = prepare(b'We ride at dawn! ')

# these all print what you would expect
print(zlib.decompress(concatenate(hello, test, fox, dawn)))
print(zlib.decompress(concatenate(dawn, fox, test, hello)))
print(zlib.decompress(concatenate(fox, hello, dawn, test)))
print(zlib.decompress(concatenate(test, dawn, hello, fox)))