XzCompress Class Reference

#include <xzcomprs.h>

Inheritance diagram for XzCompress:

Collaboration diagram for XzCompress:

Public Member Functions
virtual void	decode (void)
virtual void	encode (void)
virtual unsigned long	getChars (char *buf, unsigned long len)
virtual char *	getCompressedBuf (unsigned long *len=0)
virtual int	getLevel ()
virtual char *	getUncompressedBuf (unsigned long *len=0)
virtual unsigned long	sendChars (char *buf, unsigned long len)
virtual void	setCompressedBuf (unsigned long *len, char *buf=0)
virtual void	setLevel (int l)
virtual void	setUncompressedBuf (const char *buf=0, unsigned long *len=0)
	XzCompress ()
virtual	~XzCompress ()

Protected Attributes
char *	buf
char	direct
int	level
unsigned long	pos
unsigned long	slen
char *	zbuf
unsigned long	zlen
unsigned long	zpos

Private Attributes
SW_u64	memlimit

Detailed Description

Definition at line 34 of file xzcomprs.h.

Constructor & Destructor Documentation

SWORD_NAMESPACE_START XzCompress::XzCompress

(

)

Definition at line 39 of file xzcomprs.cpp.

                       : SWCompress() {
    level = 3;
    
    // start with the estimated memory usage for our preset
    memlimit = lzma_easy_decoder_memusage(level | LZMA_PRESET_EXTREME);
    
    // and round up to a power of 2--
    // bit twiddle hack to determine next greatest power of 2 from:
    // http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
    memlimit--;
    memlimit |= memlimit >> 1;
    memlimit |= memlimit >> 2;
    memlimit |= memlimit >> 4;
    memlimit |= memlimit >> 8;
    memlimit |= memlimit >> 16;
    memlimit++;

    // double that for safety's sake
    memlimit <<= 1;
}

XzCompress::~XzCompress ( )

virtual

Definition at line 65 of file xzcomprs.cpp.

                        {
}

Member Function Documentation

void XzCompress::decode ( void  )

virtual

Reimplemented from SWCompress.

Definition at line 131 of file xzcomprs.cpp.

                            {
    direct = 1; // set direction needed by parent [Get|Send]Chars()

    // get buffer
    char chunk[1024];
    char *zbuf = (char *)calloc(1, 1024);
    char *chunkbuf = zbuf;
    int chunklen;
    unsigned long zlen = 0;
    while((chunklen = getChars(chunk, 1023))) {
        memcpy(chunkbuf, chunk, chunklen);
        zlen += chunklen;
        if (chunklen < 1023)
            break;
        else    zbuf = (char *)realloc(zbuf, zlen + 1024);
        chunkbuf = zbuf + zlen;
    }

    //printf("Decoding complength{%ld} uncomp{%ld}\n", zlen, blen);
    if (zlen) {
        unsigned long blen = zlen*20;   // trust compression is less than 2000%
        char *buf = new char[blen]; 
        //printf("Doing decompress {%s}\n", zbuf);
        slen = 0;
        size_t zpos = 0;
        size_t bpos = 0;

        switch (lzma_stream_buffer_decode((uint64_t *)&memlimit, 0, NULL, (const uint8_t*)zbuf, &zpos, (size_t)zlen, (uint8_t*)buf, &bpos, (size_t)&blen)){
            case LZMA_OK: sendChars(buf, bpos); slen = bpos; break;
            case LZMA_FORMAT_ERROR: fprintf(stderr, "ERROR: format error encountered during decompression.\n"); break;
            case LZMA_OPTIONS_ERROR: fprintf(stderr, "ERROR: options error encountered during decompression.\n"); break;
            case LZMA_DATA_ERROR: fprintf(stderr, "ERROR: corrupt data during decompression.\n"); break;
            case LZMA_NO_CHECK: fprintf(stderr, "ERROR: no_check error encountered during decompression.\n"); break;
            case LZMA_UNSUPPORTED_CHECK: fprintf(stderr, "ERROR: unsupported_check error encountered during decompression.\n"); break;
            case LZMA_MEMLIMIT_ERROR: fprintf(stderr, "ERROR: memlimit error encountered during decompression.\n"); break;
            case LZMA_MEM_ERROR: fprintf(stderr, "ERROR: not enough memory during decompression.\n"); break;
            case LZMA_BUF_ERROR: fprintf(stderr, "ERROR: not enough room in the out buffer during decompression.\n"); break;
            case LZMA_PROG_ERROR: fprintf(stderr, "ERROR: program error encountered during decompression.\n"); break;
            default: fprintf(stderr, "ERROR: an unknown error occurred during decompression.\n"); break;
        }
        delete [] buf;
    }
    else {
        fprintf(stderr, "ERROR: no buffer to decompress!\n");
    }
    //printf("Finished decoding\n");
    free (zbuf);
}

void XzCompress::encode ( void  )

virtual

Reimplemented from SWCompress.

Definition at line 79 of file xzcomprs.cpp.

                            {

    direct = 0; // set direction needed by parent [Get|Send]Chars()

    // get buffer
    char chunk[1024];
    char *buf = (char *)calloc(1, 1024);
    char *chunkbuf = buf;
    unsigned long chunklen;
    unsigned long len = 0;
    while((chunklen = getChars(chunk, 1023))) {
        memcpy(chunkbuf, chunk, chunklen);
        len += chunklen;
        if (chunklen < 1023)
            break;
        else    buf = (char *)realloc(buf, len + 1024);
        chunkbuf = buf+len;
    }

    zlen = (long)lzma_stream_buffer_bound(len);
    char *zbuf = new char[zlen+1];
    size_t zpos = 0;

    if (len) {
        //printf("Doing compress\n");
        switch (lzma_easy_buffer_encode(level | LZMA_PRESET_EXTREME, LZMA_CHECK_CRC64, NULL, (const uint8_t*)buf, (size_t)len, (uint8_t*)zbuf, &zpos, (size_t)zlen)) {
                case LZMA_OK: sendChars(zbuf, zpos);  break;
            case LZMA_BUF_ERROR: fprintf(stderr, "ERROR: not enough room in the out buffer during compression.\n"); break;
            case LZMA_UNSUPPORTED_CHECK: fprintf(stderr, "ERROR: unsupported_check error encountered during decompression.\n"); break;
            case LZMA_OPTIONS_ERROR: fprintf(stderr, "ERROR: options error encountered during decompression.\n"); break;
            case LZMA_MEM_ERROR: fprintf(stderr, "ERROR: not enough memory during compression.\n"); break;
            case LZMA_DATA_ERROR: fprintf(stderr, "ERROR: corrupt data during compression.\n"); break;
            case LZMA_PROG_ERROR: fprintf(stderr, "ERROR: program error encountered during decompression.\n"); break;
            default: fprintf(stderr, "ERROR: an unknown error occurred during compression.\n"); break;
        }
    }
    else {
        fprintf(stderr, "ERROR: no buffer to compress\n");
    }
    delete [] zbuf;
    free (buf);
}

unsigned long SWCompress::getChars ( char *  buf, unsigned long  len  )

virtualinherited

Definition at line 121 of file swcomprs.cpp.

                                                                {
    if (direct) {
        len = (((zlen - zpos) > (unsigned)len) ? len : zlen - zpos);
        if (len > 0) {
            memmove(ibuf, &zbuf[zpos], len);
            zpos += len;
        }
    }
    else {
//      slen = strlen(buf);
        len = (((slen - pos) > (unsigned)len) ? len : slen - pos);
        if (len > 0) {
            memmove(ibuf, &buf[pos], len);
            pos += len;
        }
    }
    return len;
}

char * SWCompress::getCompressedBuf ( unsigned long *  len = 0 )

virtualinherited

Definition at line 111 of file swcomprs.cpp.

                                                     {
    if (!zbuf) {
        direct = 0;
        encode();
    }
    if (len) *len = zlen;
    return zbuf;
}

virtual int SWCompress::getLevel ( )

inlinevirtualinherited

Definition at line 54 of file swcomprs.h.

{return level;};

char * SWCompress::getUncompressedBuf ( unsigned long *  len = 0 )

virtualinherited

Definition at line 90 of file swcomprs.cpp.

                                                       {
    if (!buf) {
        buf = (char *)calloc(1,1); // be sure we at least allocate an empty buf for return;
        direct = 1;
        decode();
    }
    if (len) *len = slen;
    return buf;
}

unsigned long SWCompress::sendChars ( char *  buf, unsigned long  len  )

virtualinherited

Definition at line 141 of file swcomprs.cpp.

                                                                 {
    if (direct) {
        if (buf) {
//          slen = strlen(buf);
            if ((pos + len) > (unsigned)slen) {
                buf = (char *) realloc(buf, pos + len + 1024);
                memset(&buf[pos], 0, len + 1024);
            }
        }
        else    buf = (char *)calloc(1, len + 1024);
        memmove(&buf[pos], ibuf, len);
        pos += len;
    }
    else {
        if (zbuf) {
            if ((zpos + len) > zlen) {
                zbuf = (char *) realloc(zbuf, zpos + len + 1024);
                zlen = zpos + len + 1024;
            }
        }
        else {
            zbuf = (char *)calloc(1, len + 1024);
            zlen = len + 1024;
        }
        memmove(&zbuf[zpos], ibuf, len);
        zpos += len;
    }
    return len;
}

void SWCompress::setCompressedBuf ( unsigned long *  len, char *  buf = 0  )

virtualinherited

Definition at line 101 of file swcomprs.cpp.

                                                                {
    if (ibuf) {
        init();
        zbuf = (char *) malloc(*len);
        memcpy(zbuf, ibuf, *len);
        zlen = *len;
    }
    *len = zlen;
}

void XzCompress::setLevel ( int  l )

virtual

Reimplemented from SWCompress.

Definition at line 186 of file xzcomprs.cpp.

                               {
    level = l;

    // having changed the compression level, we need to adjust our memlimit accordingly,
    // as in the constructor:

    // start with the estimated memory usage for our preset
    memlimit = lzma_easy_decoder_memusage(level | LZMA_PRESET_EXTREME);
    
    // and round up to a power of 2--
    // bit twiddle hack to determine next greatest power of 2 from:
    // http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
    memlimit--;
    memlimit |= memlimit >> 1;
    memlimit |= memlimit >> 2;
    memlimit |= memlimit >> 4;
    memlimit |= memlimit >> 8;
    memlimit |= memlimit >> 16;
    memlimit++;

    // double that for safety's sake
    memlimit <<= 1;
};

void SWCompress::setUncompressedBuf ( const char *  buf = 0, unsigned long *  len = 0  )

virtualinherited

Definition at line 75 of file swcomprs.cpp.

                                                                        {
    if (ibuf) {
        init();
        slen = (len) ? *len : strlen(ibuf);
        buf = (char *) calloc(slen + 1, 1);
        memcpy(buf, ibuf, slen);
    }
    if (!buf) {
        buf = (char *)calloc(1,1); // be sure we at least allocate an empty buf for return;
        direct = 1;
        decode();
        if (len) *len = slen;
    }
}

Member Data Documentation

char* SWCompress::buf

mutableprotectedinherited

Definition at line 38 of file swcomprs.h.

char SWCompress::direct

mutableprotectedinherited

Definition at line 38 of file swcomprs.h.

int SWCompress::level

protectedinherited

Definition at line 40 of file swcomprs.h.

SW_u64 XzCompress::memlimit

private

Definition at line 37 of file xzcomprs.h.

unsigned long SWCompress::pos

protectedinherited

Definition at line 39 of file swcomprs.h.

unsigned long SWCompress::slen

protectedinherited

Definition at line 39 of file swcomprs.h.

char * SWCompress::zbuf

mutableprotectedinherited

Definition at line 38 of file swcomprs.h.

unsigned long SWCompress::zlen

protectedinherited

Definition at line 39 of file swcomprs.h.

unsigned long SWCompress::zpos

protectedinherited

Definition at line 39 of file swcomprs.h.

---

The documentation for this class was generated from the following files:

• include/xzcomprs.h
• src/modules/common/xzcomprs.cpp