ippcompress.c

这是在PCA下的基于IPP库示例代码例子,在网上下了IPP的库之后,设置相关参数就可以编译该代码.

/* //////////////////////////////// "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 */
}