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算法知之甚少，所以从理论的角度来看，这可能是完全不可能的。另外，我必须使用zlib;所以我不能包装zlib并提出我自己的透明处理连接流的协议。

注意：如果解决方案在Python中不重要，我真的不介意。我愿意编写一些C代码并在Python中使用ctypes。

Answer 1

由于您不介意冒险进入C，您可以先查看 gzjoin 的代码。

注意， gzjoin 代码必须解压缩才能找到合并时必须更改的部分，但不必重新压缩。这不是太糟糕，因为解压缩通常比压缩更快。

Answer 2

除了需要对第一个deflate流进行解压缩的gzjoin之外，您还可以查看gzlog.h和gzlog.c，它可以有效地将短字符串附加到gzip文件，而无需解压缩deflate流每一次。（可以很容易地修改它来操作zlib包装的deflate数据而不是gzip-wrapped 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)))

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

3 个答案: