Comment Zlib Compressez un QbyEarray?

Voici un code ICI IC une fois écrit qui obtient comme entrée un pointeur sur un tableau d'octets, le nombre d'octets à compresser et le niveau de compression puis utilise zlib pour compresser l'entrée. Le résultat est renvoyé dans une chaîne.

 enum compressionLevel
 {
    clFast,
    clSmall,
    clDefault
 };

 const size_t ChunkSize = 262144; //256k default size for chunks fed to zlib

 void compressZlib(const char *s, size_t nbytes, std::string &out, compressionLevel l /*= clDefault*/ )
 {
    int level = Z_DEFAULT_COMPRESSION;
    switch (l)
    {
    case clDefault:
        level = Z_DEFAULT_COMPRESSION; break;
    case clSmall:
        level = Z_BEST_COMPRESSION; break;
    case clFast:
        level = Z_BEST_SPEED; break;
    };

    z_stream strm;
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    int ret = deflateInit(&strm, level);
    if (ret != Z_OK)
    {
        throw std::runtime_error("Error while initializing zlib, error code "+ret);
    }
    size_t toCompress = nbytes;
    char *readp = (char*)s;
    size_t writeOffset = out.size();
    out.reserve((size_t)(nbytes * 0.7));
    while (toCompress > 0)
    {
        size_t toRead = std::min(toCompress,ChunkSize);
        int flush = toRead < toCompress ? Z_NO_FLUSH : Z_FINISH;
        strm.avail_in = toRead;
        strm.next_in = (Bytef*)readp;
        char *writep = new char[ChunkSize];
        do{
            strm.avail_out = ChunkSize;
            strm.next_out = (Bytef*)writep;
            deflate(&strm, flush);
            size_t written = ChunkSize - strm.avail_out;
            out.resize(out.size() + written);
            memcpy(&(out[writeOffset]), writep, written);
            writeOffset += written;
        } while (strm.avail_out == 0);
        delete[] writep;
        readp += toRead;
        toCompress -= toRead;
    }
    (void)deflateEnd(&strm);
 }

basé sur Ceci Note dans Quncompress, i pense que c'est assez facile.

Remarque: Si vous souhaitez utiliser cette fonction pour décompresser des données externes comprimées à l'aide de ZLIB, vous devez d'abord préparer un en-tête de quatre octets sur le tableau d'octets contenant les données. L'en-tête doit contenir la longueur attendue (en octets) des données non compressées, exprimées comme un entier non signé, Big-Endian, 32 bits.

Donc, vous pouvez probablement simplement le comprimer comme ceci: xxx

Juste pour vous aider avec la dernière section de votre question ici:

Je n'ai aucune idée de ce qu'est un bytef, je commence à regarder dans les sources de Zlib pour enquêter. p> blockQuote>

pour les définitions de octet code> et byTEF code>, regardez les lignes 332 et 333 de zconf.h, ainsi que la ligne 342: P>

QByteArray tdata = QString("Oh noes!").toUtf8();
QByteArray cdata(compressBound(tdata.length()), '\0');
uLongf len = compressBound(tdata.length());
compress(reinterpret_cast<unsigned char*>(cdata.data()), &len, 
         reinterpret_cast<unsigned char*>(tdata.data()), tdata.length());