c++ - Qtquncompressgzipデータ

Question

問題に遭遇し、解決策を見つけることができません。

だから私がやりたいのは、qUncompress（QByteArray）を使用してqtでデータを解凍し、wwwからgzip形式で送信することです。私は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はそのデータを解凍します（つまり、ID1 = 0x1f、ID2 = 0x8bですが、gzipヘッダーは表示されませんでした）デバッグで上記のコードを確認したところ、次の場所でエラーが発生しました：

        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を処理できるはずです。コメントは大歓迎です。

よろしくお願いします

Answer 1

これが私の貢献です... GZIPを使用して簡単に圧縮/解凍するためのクラス（ QCompressor）を開発しました。zlibQByteArray

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をファイルに追加する必要があります。.prozlib

Answer 2

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>

Answer 3

あなたも忘れdataPlusSize.append(data);ました。ただし、それでは問題は解決しません。問題は、gzipとzlibの圧縮データ形式は同じですが、ヘッダーとトレーラーが異なることです。参照：http ：//www.zlib.net/zlib_faq.html#faq18

qUncompresszlibuncompressを使用するため、gzip形式ではなく、zlib形式のみを処理できます。gzXXXXgzip形式を処理するに は関数を呼び出す必要があります。

qUncompressPHPからの出力を処理できる理由は、ZLIBデータ形式を使用して指定された文字列を圧縮するためですgzcompress。gzcompress参照： http： //php.net/manual/en/function.gzcompress.php

CiscoIPPhoneが述べたように、gzipデータを処理する関数に独自の関数を作成する必要があります。

Answer 4

この回答とこの回答から着想を得て、さらに簡略化された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);
  }
}