12

我偶然发现了一个问题，并且找不到解决方案。

所以我想做的是解压缩qt中的数据，使用qUncompress（QByteArray），以gzip格式从www发送。我用wireshark确定这是有效的gzip流，也用zip/rar测试过，两者都可以解压缩。

到目前为止的代码是这样的：

    static const char dat[40] = {
         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xaa, 0x2e, 0x2e, 0x49, 0x2c, 0x29,
         0x2d, 0xb6, 0x4a, 0x4b, 0xcc, 0x29, 0x4e, 0xad, 0x05, 0x00, 0x00, 0x00, 0xff, 0xff, 0x03, 0x00,
         0x2a, 0x63, 0x18, 0xc5, 0x0e, 0x00, 0x00, 0x00
    };
//this data contains string: {status:false}, in gzip format
QByteArray data;
           data.append( dat, sizeof(dat) );

unsigned int size = 14; //expected uncompresed size, reconstruct it BigEndianes

//prepand expected uncompressed size, last 4 byte in dat 0x0e = 14
QByteArray dataPlusSize;

dataPlusSize.append( (unsigned int)((size >> 24) & 0xFF));
dataPlusSize.append( (unsigned int)((size >> 16) & 0xFF));
dataPlusSize.append( (unsigned int)((size >> 8) & 0xFF));
dataPlusSize.append( (unsigned int)((size >> 0) & 0xFF));

QByteArray uncomp = qUncompress( dataPlusSize );
qDebug() << uncomp;

并且解压缩失败并显示： qUncompress: Z_DATA_ERROR: 输入数据已损坏。

AFAIK gzip 由 10 字节头、DEFLATE peyload、12 字节尾（8 字节 CRC32 + 4 字节 ISIZE - 未压缩数据大小）组成。条带化标头和拖尾应该给我留下 DEFLATE 数据流，qUncompress 产生相同的错误。

我检查了用 PHP 压缩的数据字符串，如下所示：

$stringData = gzcompress( "{status:false}", 1);

和 qUncompress 解压缩该数据。（我没有看到和 gzip 标头虽然 ie ID1 = 0x1f, ID2 = 0x8b ）我用调试检查了上面的代码，错误发生在：

        if (
        #endif
            ((BITS(8) << 8) + (hold >> 8)) % 31) { //here is error, WHY? long unsigned int hold = 35615
            strm->msg = (char *)"incorrect header check";
            state->mode = BAD;
            break;
        }

inflate.c 第 610 行。

我知道 qUncompress 只是 zlib 的一个包装器，所以我想它应该可以毫无问题地处理 gzip。任何评论都更受欢迎。

此致

4

4 回答 4

13

这是我的贡献...我开发了一个类 ( QCompressor)，基于使用 GZIPzlib轻松压缩/解压缩。QByteArray

qcompressor.h：

#ifndef QCOMPRESSOR_H
#define QCOMPRESSOR_H

#include <zlib.h>
#include <QByteArray>

#define GZIP_WINDOWS_BIT 15 + 16
#define GZIP_CHUNK_SIZE 32 * 1024

class QCompressor
{
public:
    static bool gzipCompress(QByteArray input, QByteArray &output, int level = -1);
    static bool gzipDecompress(QByteArray input, QByteArray &output);
};

#endif // QCOMPRESSOR_H

qcompressor.cpp：

#include "qcompressor.h"

/**
 * @brief Compresses the given buffer using the standard GZIP algorithm
 * @param input The buffer to be compressed
 * @param output The result of the compression
 * @param level The compression level to be used (@c 0 = no compression, @c 9 = max, @c -1 = default)
 * @return @c true if the compression was successful, @c false otherwise
 */
bool QCompressor::gzipCompress(QByteArray input, QByteArray &output, int level)
{
    // Prepare output
    output.clear();

    // Is there something to do?
    if(input.length())
    {
        // Declare vars
        int flush = 0;

        // Prepare deflater status
        z_stream strm;
        strm.zalloc = Z_NULL;
        strm.zfree = Z_NULL;
        strm.opaque = Z_NULL;
        strm.avail_in = 0;
        strm.next_in = Z_NULL;

        // Initialize deflater
        int ret = deflateInit2(&strm, qMax(-1, qMin(9, level)), Z_DEFLATED, GZIP_WINDOWS_BIT, 8, Z_DEFAULT_STRATEGY);

        if (ret != Z_OK)
            return(false);

        // Prepare output
        output.clear();

        // Extract pointer to input data
        char *input_data = input.data();
        int input_data_left = input.length();

        // Compress data until available
        do {
            // Determine current chunk size
            int chunk_size = qMin(GZIP_CHUNK_SIZE, input_data_left);

            // Set deflater references
            strm.next_in = (unsigned char*)input_data;
            strm.avail_in = chunk_size;

            // Update interval variables
            input_data += chunk_size;
            input_data_left -= chunk_size;

            // Determine if it is the last chunk
            flush = (input_data_left <= 0 ? Z_FINISH : Z_NO_FLUSH);

            // Deflate chunk and cumulate output
            do {

                // Declare vars
                char out[GZIP_CHUNK_SIZE];

                // Set deflater references
                strm.next_out = (unsigned char*)out;
                strm.avail_out = GZIP_CHUNK_SIZE;

                // Try to deflate chunk
                ret = deflate(&strm, flush);

                // Check errors
                if(ret == Z_STREAM_ERROR)
                {
                    // Clean-up
                    deflateEnd(&strm);

                    // Return
                    return(false);
                }

                // Determine compressed size
                int have = (GZIP_CHUNK_SIZE - strm.avail_out);

                // Cumulate result
                if(have > 0)
                    output.append((char*)out, have);

            } while (strm.avail_out == 0);

        } while (flush != Z_FINISH);

        // Clean-up
        (void)deflateEnd(&strm);

        // Return
        return(ret == Z_STREAM_END);
    }
    else
        return(true);
}

/**
 * @brief Decompresses the given buffer using the standard GZIP algorithm
 * @param input The buffer to be decompressed
 * @param output The result of the decompression
 * @return @c true if the decompression was successfull, @c false otherwise
 */
bool QCompressor::gzipDecompress(QByteArray input, QByteArray &output)
{
    // Prepare output
    output.clear();

    // Is there something to do?
    if(input.length() > 0)
    {
        // Prepare inflater status
        z_stream strm;
        strm.zalloc = Z_NULL;
        strm.zfree = Z_NULL;
        strm.opaque = Z_NULL;
        strm.avail_in = 0;
        strm.next_in = Z_NULL;

        // Initialize inflater
        int ret = inflateInit2(&strm, GZIP_WINDOWS_BIT);

        if (ret != Z_OK)
            return(false);

        // Extract pointer to input data
        char *input_data = input.data();
        int input_data_left = input.length();

        // Decompress data until available
        do {
            // Determine current chunk size
            int chunk_size = qMin(GZIP_CHUNK_SIZE, input_data_left);

            // Check for termination
            if(chunk_size <= 0)
                break;

            // Set inflater references
            strm.next_in = (unsigned char*)input_data;
            strm.avail_in = chunk_size;

            // Update interval variables
            input_data += chunk_size;
            input_data_left -= chunk_size;

            // Inflate chunk and cumulate output
            do {

                // Declare vars
                char out[GZIP_CHUNK_SIZE];

                // Set inflater references
                strm.next_out = (unsigned char*)out;
                strm.avail_out = GZIP_CHUNK_SIZE;

                // Try to inflate chunk
                ret = inflate(&strm, Z_NO_FLUSH);

                switch (ret) {
                case Z_NEED_DICT:
                    ret = Z_DATA_ERROR;
                case Z_DATA_ERROR:
                case Z_MEM_ERROR:
                case Z_STREAM_ERROR:
                    // Clean-up
                    inflateEnd(&strm);

                    // Return
                    return(false);
                }

                // Determine decompressed size
                int have = (GZIP_CHUNK_SIZE - strm.avail_out);

                // Cumulate result
                if(have > 0)
                    output.append((char*)out, have);

            } while (strm.avail_out == 0);

        } while (ret != Z_STREAM_END);

        // Clean-up
        inflateEnd(&strm);

        // Return
        return (ret == Z_STREAM_END);
    }
    else
        return(true);
}

这里main()是我的测试程序：

#include <QDebug>
#include "qcompressor.h"

int main(int argc, char *argv[])
{
    Q_UNUSED(argc);
    Q_UNUSED(argv);

    QString initialPlainText = "This is a test program for verifying that the QCompressor class works fine!";

    qDebug() << "Initial plain text is: " << initialPlainText;

    QByteArray compressed;

    if(QCompressor::gzipCompress(initialPlainText.toLatin1(), compressed))
    {
        qDebug() << "Compressed text length is:" << compressed.length();

        QByteArray decompressed;

        if(QCompressor::gzipDecompress(compressed, decompressed))
        {
            qDebug() << "Decompressed text is: " << QString::fromLatin1(decompressed);
        }
        else
            qDebug() << "Can't decompress";
    }
    else
        qDebug() << "Can't compress";
}

为了让它工作，您需要在文件中添加一行LIBS += -lz以.pro链接到zlib.

于 2014-07-25T06:00:59.263 回答
9

直接使用 zlib 并不难。

我一直在这样做：

QByteArray gUncompress(const QByteArray &data)
{
    if (data.size() <= 4) {
        qWarning("gUncompress: Input data is truncated");
        return QByteArray();
    }

    QByteArray result;

    int ret;
    z_stream strm;
    static const int CHUNK_SIZE = 1024;
    char out[CHUNK_SIZE];

    /* allocate inflate state */
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    strm.avail_in = data.size();
    strm.next_in = (Bytef*)(data.data());

    ret = inflateInit2(&strm, 15 +  32); // gzip decoding
    if (ret != Z_OK)
        return QByteArray();

    // run inflate()
    do {
        strm.avail_out = CHUNK_SIZE;
        strm.next_out = (Bytef*)(out);

        ret = inflate(&strm, Z_NO_FLUSH);
        Q_ASSERT(ret != Z_STREAM_ERROR);  // state not clobbered

        switch (ret) {
        case Z_NEED_DICT:
            ret = Z_DATA_ERROR;     // and fall through
        case Z_DATA_ERROR:
        case Z_MEM_ERROR:
            (void)inflateEnd(&strm);
            return QByteArray();
        }

        result.append(out, CHUNK_SIZE - strm.avail_out);
    } while (strm.avail_out == 0);

    // clean up and return
    inflateEnd(&strm);
    return result;
}

该代码是从 zlib 代码示例页面复制而来的。您将需要include <zlib.h>

于 2011-09-08T16:37:11.683 回答
6

你也忘了dataPlusSize.append(data);。但是，这并不能解决您的问题。问题在于，虽然 gzip 和 zlib 具有相同的压缩数据格式，但它们的标头和尾标却不同。见：http ://www.zlib.net/zlib_faq.html#faq18

qUncompress使用 zlib uncompress，所以它只能处理 zlib 格式，不能处理 gzip 格式。它需要调用gzXXXX函数来处理 gzip 格式。

qUncompress可以处理来自 PHP 的输出的原因gzcompress是gzcompress使用 ZLIB 数据格式压缩给定的字符串。见： http: //php.net/manual/en/function.gzcompress.php

正如 CiscoIPPhone 所提到的，您需要编写自己的函数来处理 gzip 数据。

于 2010-04-22T16:33:18.943 回答
0

受这个答案和这个答案的启发，我编写了进一步简化的 C++ 代码。它独立于 Qt。

namespace Zlib
{
  using std::string;

#define GZIP(FUNCTION, ...) \
  static const size_t CHUNK_SIZE = 1000000; \
  ::z_stream stream = {}; \
  VERIFY(FUNCTION##Init2(&stream, __VA_ARGS__) == Z_OK, ""); \
  FINALLY_CALL(:FUNCTION##End(&stream)); \
  \
  string output; \
  for(int flush = Z_NO_FLUSH; flush == Z_NO_FLUSH; stream.avail_out = 0) \
  { \
    const auto pending = input.size() - stream.total_in; \
    stream.avail_in = std::min(CHUNK_SIZE, pending); \
    stream.next_in = reinterpret_cast<Bytef*>(const_cast<char*>(input.data()) + stream.total_in); \
    \
    while(stream.avail_out == 0) \
    { \
      stream.avail_out = CHUNK_SIZE; \
      output.resize(stream.total_out + stream.avail_out); \
      stream.next_out = reinterpret_cast<Bytef*>(&output[0] + stream.total_out); \
      \
      flush = (stream.avail_in == pending)? Z_FINISH : Z_NO_FLUSH; \
      FUNCTION(&stream, flush); \
    } \
  } \
  output.resize(stream.total_out); \
  return output


  string
  StringToGzip (const string& input,
                const int level = Z_DEFAULT_COMPRESSION)
  {
    GZIP(::deflate, level, Z_DEFLATED, 15 | 16, 8, Z_DEFAULT_STRATEGY);
  }

  string
  GzipToString (const string& input)
  {
    GZIP(::inflate, 15 | 16);
  }
}
于 2021-08-30T11:04:05.527 回答