From 9cb2695ad318dcda83a353b03c21b4fd71d0f9d6 Mon Sep 17 00:00:00 2001 From: Mike Buland Date: Mon, 24 Oct 2011 16:30:39 +0000 Subject: Made the encoder state opaque to the caller in Deflate and BZip2 to match Lzma. That means that when you use Bu::Deflate, Bu::Bzip2, or Bu::Lzma you don't get any of the respective libraries' header files. --- src/deflate.cpp | 120 ++++++++++++++++++++++++++++++-------------------------- 1 file changed, 65 insertions(+), 55 deletions(-) (limited to 'src/deflate.cpp') diff --git a/src/deflate.cpp b/src/deflate.cpp index aec2a18..10a9c5f 100644 --- a/src/deflate.cpp +++ b/src/deflate.cpp @@ -8,10 +8,15 @@ #include "bu/deflate.h" #include "bu/trace.h" +#include + +#define pState ((z_stream *)prState) + using namespace Bu; Bu::Deflate::Deflate( Bu::Stream &rNext, int nCompression, Format eFmt ) : Bu::Filter( rNext ), + prState( NULL ), nCompression( nCompression ), sTotalOut( 0 ), eFmt( eFmt ), @@ -30,10 +35,11 @@ Bu::Deflate::~Deflate() void Bu::Deflate::start() { TRACE(); - zState.zalloc = NULL; - zState.zfree = NULL; - zState.opaque = NULL; - zState.state = NULL; + prState = new z_stream; + pState->zalloc = NULL; + pState->zfree = NULL; + pState->opaque = NULL; + pState->state = NULL; nBufSize = 64*1024; pBuf = new char[nBufSize]; @@ -42,34 +48,38 @@ void Bu::Deflate::start() Bu::size Bu::Deflate::stop() { TRACE(); - if( zState.state ) + if( pState && pState->state ) { if( bReading ) { - inflateEnd( &zState ); + inflateEnd( pState ); delete[] pBuf; pBuf = NULL; + delete pState; + prState = NULL; return 0; } else { for(;;) { - zState.next_in = NULL; - zState.avail_in = 0; - zState.avail_out = nBufSize; - zState.next_out = (Bytef *)pBuf; - int res = deflate( &zState, Z_FINISH ); - if( zState.avail_out < nBufSize ) + pState->next_in = NULL; + pState->avail_in = 0; + pState->avail_out = nBufSize; + pState->next_out = (Bytef *)pBuf; + int res = deflate( pState, Z_FINISH ); + if( pState->avail_out < nBufSize ) { - sTotalOut += rNext.write( pBuf, nBufSize-zState.avail_out ); + sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out ); } if( res == Z_STREAM_END ) break; } - deflateEnd( &zState ); + deflateEnd( pState ); delete[] pBuf; pBuf = NULL; + delete pState; + prState = NULL; return sTotalOut; } } @@ -87,25 +97,25 @@ void Bu::Deflate::zError( int code ) return; case Z_ERRNO: - throw ExceptionBase("Deflate: Errno - %s", zState.msg ); + throw ExceptionBase("Deflate: Errno - %s", pState->msg ); case Z_STREAM_ERROR: - throw ExceptionBase("Deflate: Stream Error - %s", zState.msg ); + throw ExceptionBase("Deflate: Stream Error - %s", pState->msg ); case Z_DATA_ERROR: - throw ExceptionBase("Deflate: Data Error - %s", zState.msg ); + throw ExceptionBase("Deflate: Data Error - %s", pState->msg ); case Z_MEM_ERROR: - throw ExceptionBase("Deflate: Mem Error - %s", zState.msg ); + throw ExceptionBase("Deflate: Mem Error - %s", pState->msg ); case Z_BUF_ERROR: - throw ExceptionBase("Deflate: Buf Error - %s", zState.msg ); + throw ExceptionBase("Deflate: Buf Error - %s", pState->msg ); case Z_VERSION_ERROR: - throw ExceptionBase("Deflate: Version Error - %s", zState.msg ); + throw ExceptionBase("Deflate: Version Error - %s", pState->msg ); default: - throw ExceptionBase("Deflate: Unknown error encountered - %s.", zState.msg ); + throw ExceptionBase("Deflate: Unknown error encountered - %s.", pState->msg ); } } @@ -113,55 +123,55 @@ void Bu::Deflate::zError( int code ) Bu::size Bu::Deflate::read( void *pData, Bu::size nBytes ) { TRACE( pData, nBytes ); - if( !zState.state ) + if( !pState->state ) { bReading = true; if( eFmt&AutoDetect ) - inflateInit2( &zState, 32+15 ); // Auto-detect, large window + inflateInit2( pState, 32+15 ); // Auto-detect, large window else if( eFmt == Raw ) - inflateInit2( &zState, -15 ); // Raw + inflateInit2( pState, -15 ); // Raw else if( eFmt == Zlib ) - inflateInit2( &zState, 15 ); // Zlib + inflateInit2( pState, 15 ); // Zlib else if( eFmt == Gzip ) - inflateInit2( &zState, 16+15 ); // GZip + inflateInit2( pState, 16+15 ); // GZip else throw Bu::ExceptionBase("Format mode for deflate read."); - zState.next_in = (Bytef *)pBuf; - zState.avail_in = 0; + pState->next_in = (Bytef *)pBuf; + pState->avail_in = 0; } if( bReading == false ) throw ExceptionBase("This deflate filter is in writing mode, you can't read."); int nRead = 0; - int nReadTotal = zState.total_out; - zState.next_out = (Bytef *)pData; - zState.avail_out = nBytes; + int nReadTotal = pState->total_out; + pState->next_out = (Bytef *)pData; + pState->avail_out = nBytes; for(;;) { - int ret = inflate( &zState, Z_NO_FLUSH ); + int ret = inflate( pState, Z_NO_FLUSH ); printf("inflate returned %d; avail in=%d, out=%d\n", ret, - zState.avail_in, zState.avail_out ); + pState->avail_in, pState->avail_out ); - nReadTotal += nRead-zState.avail_out; + nReadTotal += nRead-pState->avail_out; if( ret == Z_STREAM_END ) { bEos = true; - if( zState.avail_in > 0 ) + if( pState->avail_in > 0 ) { if( rNext.isSeekable() ) { - rNext.seek( -zState.avail_in ); + rNext.seek( -pState->avail_in ); } } - return nBytes-zState.avail_out; + return nBytes-pState->avail_out; } if( ret != Z_BUF_ERROR ) zError( ret ); - if( zState.avail_out ) + if( pState->avail_out ) { - if( zState.avail_in == 0 ) + if( pState->avail_in == 0 ) { nRead = rNext.read( pBuf, nBufSize ); if( nRead == 0 && rNext.isEos() ) @@ -169,13 +179,13 @@ Bu::size Bu::Deflate::read( void *pData, Bu::size nBytes ) throw Bu::ExceptionBase("Premature end of underlying " "stream found reading deflate stream."); } - zState.next_in = (Bytef *)pBuf; - zState.avail_in = nRead; + pState->next_in = (Bytef *)pBuf; + pState->avail_in = nRead; } } else { - return nBytes-zState.avail_out; + return nBytes-pState->avail_out; } } return 0; @@ -184,18 +194,18 @@ Bu::size Bu::Deflate::read( void *pData, Bu::size nBytes ) Bu::size Bu::Deflate::write( const void *pData, Bu::size nBytes ) { TRACE( pData, nBytes ); - if( !zState.state ) + if( !pState->state ) { bReading = false; int iFmt = eFmt&Gzip; if( iFmt == Raw ) - deflateInit2( &zState, nCompression, Z_DEFLATED, -15, 9, + deflateInit2( pState, nCompression, Z_DEFLATED, -15, 9, Z_DEFAULT_STRATEGY ); else if( iFmt == Zlib ) - deflateInit2( &zState, nCompression, Z_DEFLATED, 15, 9, + deflateInit2( pState, nCompression, Z_DEFLATED, 15, 9, Z_DEFAULT_STRATEGY ); else if( iFmt == Gzip ) - deflateInit2( &zState, nCompression, Z_DEFLATED, 16+15, 9, + deflateInit2( pState, nCompression, Z_DEFLATED, 16+15, 9, Z_DEFAULT_STRATEGY ); else throw Bu::ExceptionBase("Invalid format for deflate."); @@ -203,20 +213,20 @@ Bu::size Bu::Deflate::write( const void *pData, Bu::size nBytes ) if( bReading == true ) throw ExceptionBase("This deflate filter is in reading mode, you can't write."); - zState.next_in = (Bytef *)pData; - zState.avail_in = nBytes; + pState->next_in = (Bytef *)pData; + pState->avail_in = nBytes; for(;;) { - zState.avail_out = nBufSize; - zState.next_out = (Bytef *)pBuf; + pState->avail_out = nBufSize; + pState->next_out = (Bytef *)pBuf; - zError( deflate( &zState, Z_NO_FLUSH ) ); + zError( deflate( pState, Z_NO_FLUSH ) ); - if( zState.avail_out < nBufSize ) + if( pState->avail_out < nBufSize ) { - sTotalOut += rNext.write( pBuf, nBufSize-zState.avail_out ); + sTotalOut += rNext.write( pBuf, nBufSize-pState->avail_out ); } - if( zState.avail_in == 0 ) + if( pState->avail_in == 0 ) break; } @@ -226,7 +236,7 @@ Bu::size Bu::Deflate::write( const void *pData, Bu::size nBytes ) bool Bu::Deflate::isOpen() { TRACE(); - return (zState.state != NULL); + return (pState != NULL && pState->state != NULL); } bool Bu::Deflate::isEos() -- cgit v1.2.3