/builddir/build/BUILD/libutil++-1.4.0/src/sella/util/Compress.cpp

/*
** libutil++
** $Id: Compress.cpp 1230 2014-11-16 02:32:01Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: Compress.cpp 1230 2014-11-16 02:32:01Z sella $";

#include "Compress.h"
#include "CommonMacro.h"

#include <zlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <assert.h>

#define SET_BINARY_MODE(file)

#define CHUNK 16384
//#define DUMP

using namespace sella::util;

Compress::Compress(int level) : c(NULL), un(NULL), clen(0), unlen(0) {
        setLevel(level);
}

Compress::Compress(const Compress &other) :
        level(other.level),
        c(malloc(other.clen)),
        un(malloc(other.unlen)),

        clen(other.clen),
        unlen(other.unlen)
{
        memcpy(this->c, other.c, this->clen);
        memcpy(this->un, other.un, this->unlen);
}

Compress::~Compress() {
        clear();
}

Compress& Compress::operator=(const Compress &other) throw () {
        if (this != &other) {
                this->level = other.level;
                this->clen = other.clen;
                this->unlen = other.unlen;
        }

        c = malloc(this->clen);
        memcpy(this->c, other.c, this->clen);

        un = malloc(this->unlen);
        memcpy(this->un, other.un, this->unlen);

        return *this;
}

void Compress::clear(void) {
        SAFE_FREE(c);
        SAFE_FREE(un);

        clen = 0;
        unlen = 0;
}

void Compress::setLevel(int level) {
        this->level = level;
}

int Compress::getLevel(void) const {
        return level;
}

bool Compress::deflate(const void *uncompressed, size_t len) {
        bool retval = true;
        int ret;
        unsigned int avail_out;
        z_stream strm;

        SAFE_FREE(c);
        clen = 0;

#ifdef DUMP
        printf("deflate: uncompressed(%d): 0x", len);
        for (int i = 0; i < len; i++) {
                printf("%.2x", ((unsigned char*) uncompressed)[i]);
        }
        printf("\n");
#endif

        if (uncompressed == NULL || len < 1) {
                return false;
        }

        /* allocate deflate state */
        strm.zalloc = Z_NULL;
        strm.zfree = Z_NULL;
        strm.opaque = Z_NULL;

        if ((ret = deflateInit(&strm, level)) != Z_OK) {
                return false;
        }

        avail_out = deflateBound(&strm, len);

        if ((c = malloc(avail_out)) == NULL) {
                retval = false;

                goto cleanup;
        }

        strm.next_in = (Bytef*) uncompressed;
        strm.avail_in = len;
        strm.next_out = (Bytef*) c;
        strm.avail_out = avail_out;

        if ((ret = ::deflate(&strm, Z_FINISH)) == Z_STREAM_ERROR) {
                retval = false;

                goto cleanup;
        }

        if (strm.avail_out == 0) {
                retval = false;

                goto cleanup;
        }

        clen = strm.total_out;

#ifdef DUMP
        printf("deflate: compressed(%d): 0x", clen);
        for (int i = 0; i < clen; i++) {
                printf("%.2x", ((unsigned char*) c)[i]);
        }
        printf("\n");
#endif

cleanup:
        (void) deflateEnd(&strm);

        if (!retval) {
                SAFE_FREE(c);
                clen = 0;
        }

        return retval;
}

bool Compress::inflate(const void *compressed, size_t len) {
        bool retval = true;
        int ret;
        unsigned int delta;
        z_stream strm;
        unsigned char buf[CHUNK];
        void *ptr;

        SAFE_FREE(un);
        unlen = 0;

#ifdef DUMP
        printf("inflate: compressed(%d): 0x", len);
        for (int i = 0; i < len; i++) {
                printf("%.2x", ((unsigned char*) compressed)[i]);
        }
        printf("\n");
#endif

        if (compressed == NULL || len < 1) {
                return false;
        }

        /* allocate deflate state */
        strm.zalloc = Z_NULL;
        strm.zfree = Z_NULL;
        strm.opaque = Z_NULL;
        strm.avail_in = 0;
        strm.next_in = Z_NULL;

        if ((ret = inflateInit(&strm)) != Z_OK) {
                return false;
        }

        strm.avail_in = len;
        strm.next_in = (Bytef*) compressed;

        do {
                strm.avail_out = CHUNK;
                strm.next_out = buf;

                ret = ::inflate(&strm, Z_NO_FLUSH);
                if (ret != Z_OK && ret != Z_STREAM_END) {
                        retval = false;

                        goto error;
                }

                /* Resize and append next_out. */
                un = realloc(un, strm.total_out);
                delta = CHUNK - strm.avail_out;
                ptr = (Bytef*) un + (strm.total_out - delta);
                memcpy(ptr, buf, delta);
        } while (strm.avail_out == 0);

error:
        (void) inflateEnd(&strm);

        if (!retval) {
                SAFE_FREE(un);
                unlen = 0;
        }

        return retval;
}

const void* Compress::getCompressed(void) const {
        return c;
}

const void* Compress::getUncompressed(void) const {
        return un;
}

size_t Compress::getCompressedLen(void) const {
        return clen;
}

size_t Compress::getUncompressedLen(void) const {
        return unlen;
}

/*
** vim: noet ts=3 sw=3
*/

---