/* //////////////////////////////// "ippcompress_bwt.c" /////////////////////////////////                  INTEL CORPORATION PROPRIETARY INFORMATION//     This software is supplied under the terms of a license agreement or//     nondisclosure agreement with Intel Corporation and may not be copied//     or disclosed except in accordance with the terms of that agreement.//          Copyright(c) 2005 Intel Corporation. All Rights Reserved.//////          Sample of IPP DC ( data compression ) domain BWT, MTF, RLE and Huffman//          encoding functions usage*/#include "bwtscheme.h"#include "gitscheme.h"#include "zlibscheme.h"#include "lzssscheme.h"void usage(char *name) {    char usage_message[] = \    "\nCopyright(c) 2005 Intel Corporation. All Rights Reserved.\nippcompress datacompression sample\n"    "Usage: %s [ -bwt | -git | -lzss | -gzip | -zlib ] [-1...-9] source_filename destination_filename\n"    " -bwt, -git, -lzss, -gzip, -zlib ...   Defines compression algorithms chain by name\n"    " -1 ... -9                             Sets the custom size of the input block while encoding from 1...9 \n"    "                                       where 1 means 100Kb, 2 means 200Kb, ... 9 means 900Kb\n"    " source_filename                       File to encode\n"    " destination_filename                  Encoded file\n"    "\nNote, that order of the arguments is predefined!\n"    "\nExample: %s -git -3 file1 file1.compr\n";    fprintf( stderr, usage_message, name, name );    exit(1);}int main( int argC, char **argV ) {    int blocksize       = 0,        DstLen          = 0,        SrcLen          = 0,        filesize        = 0,        filesizer       = 0;    bwtState *pBWTState = NULL;    gitState *pGITState = NULL;    IppHuffState_8u *pHuffState = NULL;    Ipp8u * pSrc        = NULL,          * pDst        = NULL,            header[4];    char    outmode[4];    /* input and output files descriptors (including gzip file descriptor when -gzip method flag)*/    FILE   * fi         = NULL,           * fo         = NULL;    gzFile   fgzip      = NULL;    /* predefined variables values */    IppGITStrategyHint strategyHint = DEFAULTGITSTRATEGY;    int gzipMode                    = GZIPAVERAGE;    int encodeMethod                = 0;    /* in case, when we deal with a static libraries, *     * init the best one for the current architecture */    if( ippStaticInit() < 0 ) {        fprintf( stderr, "Can't init IPP libraries. Exiting.\n");        exit(-1);    }    /* in case when extra parameters or missing some of prints the usage message and exits*/    if( argC < 4 || argC > 5 ) usage( argV[0] );    if( argV[1][0] == '-' ) {        if( strcmp( argV[1], "-bwt"  ) == 0 ) encodeMethod = BWT;        // RLE->BWT->MTF->RLE->Huffman scheme        if( strcmp( argV[1], "-git"  ) == 0 ) encodeMethod = GIT;        // BWT->GIT scheme        if( strcmp( argV[1], "-lzss" ) == 0 ) encodeMethod = LZSS;       // LZSS scheme        if( strcmp( argV[1], "-zlib" ) == 0 ) encodeMethod = ZLIB;       // ZLIB scheme (deflate)        if( strcmp( argV[1], "-gzip" ) == 0 ) encodeMethod = ZGZIP;      // ZGZIP scheme (gzwrite)        if( strcmp( argV[1], "-huffman" ) == 0 ) encodeMethod = HUFFMAN; // ZGZIP scheme (gzwrite)        if( encodeMethod == 0) usage(argV[0]);    }    else usage(argV[0]);    /* prints usage message */    /* gets a size of block parameter from a command line */    if( argV[2][0] != '-' || argV[2][1] > '9' || argV[2][1] < '1' || argV[3] == 0 || argV[4] == 0 ) {        fprintf( stderr, "Error in command line");        usage( argV[0] );    }    /* opens input file */    if( NULL == ( fi = fopen( argV[3], "rb" ) ) ) {        fprintf( stderr, "Error while reading source file!\n" );        exit(1);    } else { /* if everething is OK, checks the filesize */        while( !feof(fi) )            filesize += fread( header, sizeof(Ipp8u), 4, fi );        blocksize = filesize;        rewind(fi);    }    /* Converts blocksize from command line to int       In case of LZSS we have to encode the entire file instead of block-by-block */    if( encodeMethod != LZSS && encodeMethod != ZLIB ) blocksize = (int)(argV[2][1] - 48) * BLOCKUNIT;    /* opens output file (if gzip encoding case - uses gzopen function and 'gzfile *file' descriptor )*/    if( encodeMethod == ZGZIP ) { /* gzip */        sprintf(outmode, "wb%d", gzipMode);        if( ( fgzip = gzopen( argV[4], outmode ) ) == NULL ) {            fprintf(stderr, "Error writing destination file!\n");            exit(2);        }    } else { /* others */        if( NULL == ( fo = fopen( argV[4], "wb" ) ) ) {            fprintf(stderr, "Error writing destination file!\n");            exit(2);        }    }    /*  writes a 5 service bytes in case of -bwt, -git, -lzss and -zlib cases.        for gzip-files compatibility, not writes this bytes in -gzip case */    if( encodeMethod != ZGZIP ) {        /* writes the method (1 to 4) of compression to first byte */        fwrite( &encodeMethod, sizeof(Ipp8u), 1, fo );        /* writes the compression block size (or destination filesize) to next 4 bytes */        fwrite( &blocksize, sizeof(Ipp32u), 1, fo );    } else {        blocksize = GZIPBLOCKSIZE; /* hint: change it to define */    }    /* allocates enough memory for input and output buffer */    pSrc = (Ipp8u *)malloc(sizeof(Ipp8u)*(blocksize<<1));    pDst = (Ipp8u *)malloc(sizeof(Ipp8u)*(blocksize<<1));    /* make method-dependable init */    switch( encodeMethod ) {        case BWT: Compress1StateInitAlloc( &pBWTState, blocksize ); break;        case GIT: Compress2StateInitAlloc( &pGITState, blocksize, strategyHint ); break;    }    switch ( encodeMethod ) {        case BWT: /* BWT -> MTF -> RLE -> Huffman */            while( ( SrcLen = (int)fread( pSrc, sizeof(Ipp8u), blocksize, fi ) ) > 0  ) {                /* sets the size of destination buffer equal to size of memory allocated */                DstLen = (blocksize<<1);                /* compress readed block */                Compress1( &pSrc, SrcLen, &pDst, &DstLen, pBWTState );                /* writes the 4 bytes (block length) into output file */                fwrite( &DstLen, sizeof(Ipp32u), 1, fo );                /* writes the (block length) bytes into output file */                fwrite( pDst, sizeof(Ipp8u), DstLen, fo );            }        break;        case GIT: /* BWT -> GIT */            while( ( SrcLen = (int)fread( pSrc, sizeof(Ipp8u), blocksize, fi ) ) > 0  ) {                /* sets the size of destination buffer equal to size of memory allocated */                DstLen = (blocksize<<1);                /* compress readed block */                Compress2( &pSrc, SrcLen, &pDst, &DstLen, pGITState );                /* writes the 4 bytes (block length) into output file */                fwrite( &DstLen, sizeof(Ipp32u), 1, fo );                /* then writes the (block length) bytes into output file */                fwrite( pDst, sizeof(Ipp8u), DstLen, fo );            }        break;        case LZSS: /* LZSS */            /* read entire file to pSrc vector */            SrcLen = fread( pSrc, sizeof(Ipp8u), blocksize, fi );            DstLen = blocksize << 1;            /* compress readed block */            CompressLZSS( pSrc, SrcLen, pDst, &DstLen );            /* writes the (block length) bytes into output file */            fwrite( pDst, sizeof(Ipp8u), DstLen, fo );        break;        case ZLIB: /* ZLIB */            SrcLen = fread( pSrc, sizeof(Ipp8u), blocksize, fi );            DstLen = blocksize << 1;            CompressZLIB( pSrc, SrcLen, pDst, &DstLen );            fwrite( pDst, sizeof(Ipp8u), DstLen, fo );        break;        case ZGZIP: /* GZIP */            SrcLen = blocksize;            for( ; SrcLen > 0 ; ) {                SrcLen = fread( pSrc, sizeof(Ipp8u), blocksize, fi );                if( ( DstLen = gzwrite( fgzip, pSrc, (unsigned)SrcLen ) != SrcLen ) )                    return (-1);            }        break;        case HUFFMAN: /* HUFFMAN only */            while( ( SrcLen = (int)fread( pSrc, sizeof(Ipp8u), blocksize, fi ) ) > 0  ) {                /* sets the size of destination buffer equal to size of memory allocated */                DstLen = (blocksize<<1);                /* compress readed block */                if( !EncodeHuffman( pSrc, SrcLen, pDst, &DstLen, pHuffState ) ) {            bwtState *pBWTState = NULL;    gitState *pGITState = NULL;                    /* writes the 4 bytes (block length) into output file */                    fwrite( &DstLen, sizeof(Ipp32u), 1, fo );                    /* writes the (block length) bytes into output file */                    fwrite( pDst, sizeof(Ipp8u), DstLen, fo );                }            }        break;    }    /* does finish tasks: close files, clean buffers */    if( encodeMethod == ZGZIP )        gzclose(fgzip);    else        fclose(fo);    fclose(fi);    fo = fopen( argV[4], "rb" );    fseek( fo, 0, SEEK_END );    filesizer = ftell( fo );    fclose( fo );    printf("Compressed file %s (%d bytes) to file %s (%d bytes)\n", argV[3], filesize, argV[4], filesizer);    if( encodeMethod == BWT ) Free1State(pBWTState);    if( encodeMethod == GIT ) Free2State(pGITState);    pBWTState = NULL;    pGITState = NULL;    free(pSrc);    free(pDst);    return 0; /* everything is OK */}