开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
bzip2.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：18k
源码类别：

生物技术

开发平台：

C/C++

bzip2.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: bzip2.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:40:54  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.9
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: bzip2.cpp,v 1000.2 2004/06/01 19:40:54 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *  Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Authors:  Vladimir Ivanov
  36.  *
  37.  * File Description:  BZip2 Compression API
  38.  *
  39.  */
  41. #include <ncbi_pch.hpp>
  42. #include <util/compress/bzip2.hpp>
  45. BEGIN_NCBI_SCOPE
  48. //////////////////////////////////////////////////////////////////////////////
  49. //
  50. // CBZip2Compression
  51. //
  54. CBZip2Compression::CBZip2Compression(ELevel level, int verbosity,
  55.                                      int work_factor, int small_decompress)
  56.     : CCompression(level), m_Verbosity(verbosity), m_WorkFactor(work_factor),
  57.       m_SmallDecompress(small_decompress)
  58. {
  59.     // Initialize the compressor stream structure
  60.     memset(&m_Stream, 0, sizeof(m_Stream));
  61.     return;
  62. }
  65. CBZip2Compression::~CBZip2Compression(void)
  66. {
  67.     return;
  68. }
  71. CCompression::ELevel CBZip2Compression::GetLevel(void) const
  72. {
  73.     CCompression::ELevel level = CCompression::GetLevel();
  74.     // BZip2 do not support a zero compression level -- make conversion 
  75.     if ( level == eLevel_NoCompression) {
  76.         return eLevel_Lowest;
  77.     }
  78.     return level;
  79. }
  82. bool CBZip2Compression::CompressBuffer(
  83.                         const void* src_buf, unsigned int  src_len,
  84.                         void*       dst_buf, unsigned int  dst_size,
  85.                         /* out */            unsigned int* dst_len)
  86. {
  87.     // Check parameters
  88.     if ( !src_buf || !src_len ) {
  89.         *dst_len = 0;
  90.         SetError(BZ_OK);
  91.         return true;
  92.     }
  93.     if ( !dst_buf || !dst_len ) {
  94.         SetError(BZ_PARAM_ERROR, "bad argument");
  95.         ERR_POST(FormatErrorMessage("CBZip2Compression::CompressBuffer"));
  96.         return false;
  97.     }
  98.     // Destination buffer size
  99.     *dst_len = dst_size;
  100.     // Compress buffer
  101.     int errcode = BZ2_bzBuffToBuffCompress((char*)dst_buf, dst_len,
  102.                                            (char*)src_buf, src_len,
  103.                                            GetLevel(), 0, 0 );
  104.     SetError(errcode, GetBZip2ErrorDescription(errcode));
  105.     if ( errcode != BZ_OK) {
  106.         ERR_POST(FormatErrorMessage("CBZip2Compression::CompressBuffer"));
  107.         return false;
  108.     }
  109.     return true;
  110. }
  113. bool CBZip2Compression::DecompressBuffer(
  114.                         const void* src_buf, unsigned int  src_len,
  115.                         void*       dst_buf, unsigned int  dst_size,
  116.                         /* out */            unsigned int* dst_len)
  117. {
  118.     // Check parameters
  119.     if ( !src_buf || !src_len ) {
  120.         *dst_len = 0;
  121.         SetError(BZ_OK);
  122.         return true;
  123.     }
  124.     if ( !dst_buf || !dst_len ) {
  125.         SetError(BZ_PARAM_ERROR, "bad argument");
  126.         return false;
  127.     }
  128.     // Destination buffer size
  129.     *dst_len = dst_size;
  130.     // Decompress buffer
  131.     int errcode = BZ2_bzBuffToBuffDecompress((char*)dst_buf, dst_len,
  132.                                              (char*)src_buf, src_len, 0, 0 );
  133.     SetError(errcode, GetBZip2ErrorDescription(errcode));
  134.     if ( errcode != BZ_OK ) {
  135.         ERR_POST(FormatErrorMessage("CBZip2Compression::DecompressBuffer"));
  136.         return false;
  137.     }
  138.     return true;
  139. }
  142. bool CBZip2Compression::CompressFile(const string& src_file,
  143.                                      const string& dst_file,
  144.                                      size_t        buf_size)
  145. {
  146.     CBZip2CompressionFile cf(dst_file,
  147.                              CCompressionFile::eMode_Write, GetLevel(),
  148.                              m_Verbosity, m_WorkFactor, m_SmallDecompress);
  149.     if ( CCompression::x_CompressFile(src_file, cf, buf_size) ) {
  150.         return cf.Close();
  151.     }
  152.     // Save error info
  153.     int    errcode = cf.GetErrorCode();
  154.     string errmsg  = cf.GetErrorDescription();
  155.     // Close file
  156.     cf.Close();
  157.     // Restore previous error info
  158.     SetError(errcode, errmsg.c_str());
  159.     return false;
  160. }
  163. bool CBZip2Compression::DecompressFile(const string& src_file,
  164.                                        const string& dst_file,
  165.                                        size_t        buf_size)
  166. {
  167.     CBZip2CompressionFile cf(src_file,
  168.                              CCompressionFile::eMode_Read, GetLevel(),
  169.                              m_Verbosity, m_WorkFactor, m_SmallDecompress);
  170.     if ( CCompression::x_DecompressFile(cf, dst_file, buf_size) ) {
  171.         return cf.Close();
  172.     }
  173.     // Save error info
  174.     int    errcode = cf.GetErrorCode();
  175.     string errmsg  = cf.GetErrorDescription();
  176.     // Close file
  177.     cf.Close();
  178.     // Restore previous error info
  179.     SetError(errcode, errmsg.c_str());
  180.     return false;
  181. }
  184. // Please, see a ftp://sources.redhat.com/pub/bzip2/docs/manual_3.html#SEC17
  185. // for detailed error descriptions.
  186. const char* CBZip2Compression::GetBZip2ErrorDescription(int errcode)
  187. {
  188.     const int kErrorCount = 9;
  189.     static const char* kErrorDesc[kErrorCount] = {
  190.         "SEQUENCE_ERROR",
  191.         "PARAM_ERROR",
  192.         "MEM_ERROR",
  193.         "DATA_ERROR",
  194.         "DATA_ERROR_MAGIC",
  195.         "IO_ERROR",
  196.         "UNEXPECTED_EOF",
  197.         "OUTBUFF_FULL",
  198.         "CONFIG_ERROR"
  199.     };
  200.     // errcode must be negative
  201.     if ( errcode >= 0  ||  errcode < -kErrorCount ) {
  202.         return 0;
  203.     }
  204.     return kErrorDesc[-errcode - 1];
  205. }
  208. string CBZip2Compression::FormatErrorMessage(string where,
  209.                                              bool   use_stream_data) const
  210. {
  211.     string str = "[" + where + "]  " + GetErrorDescription();
  212.     if ( use_stream_data ) {
  213.         str += ";  error code = " +
  214.             NStr::IntToString(GetErrorCode()) +
  215.             ", number of processed bytes = " +
  216.             NStr::UInt8ToString(((Uint8)m_Stream.total_in_hi32 << 32) +
  217.                                 (Uint8)m_Stream.total_in_lo32);
  218.     }
  219.     return str + ".";
  220. }
  224. //////////////////////////////////////////////////////////////////////////////
  225. //
  226. // CBZip2CompressionFile
  227. //
  230. CBZip2CompressionFile::CBZip2CompressionFile(
  231.     const string& file_name, EMode mode,
  232.     ELevel level, int verbosity, int work_factor, int small_decompress)
  233.     : CBZip2Compression(level, verbosity, work_factor, small_decompress), 
  234.       m_FileStream(0)
  235. {
  236.     if ( !Open(file_name, mode) ) {
  237.         const string smode = (mode == eMode_Read) ? "reading" : "writing";
  238.         NCBI_THROW(CCompressionException, eCompressionFile, 
  239.                    "[CBZip2CompressionFile]  Cannot open file '" + file_name +
  240.                    "' for " + smode + ".");
  241.     }
  242.     return;
  243. }
  246. CBZip2CompressionFile::CBZip2CompressionFile(
  247.     ELevel level, int verbosity, int work_factor, int small_decompress)
  248.     : CBZip2Compression(level, verbosity, work_factor, small_decompress), 
  249.       m_FileStream(0), m_EOF(true)
  250. {
  251.     return;
  252. }
  255. CBZip2CompressionFile::~CBZip2CompressionFile(void)
  256. {
  257.     Close();
  258.     return;
  259. }
  262. bool CBZip2CompressionFile::Open(const string& file_name, EMode mode)
  263. {
  264.     int errcode;
  265.    
  266.     if ( mode == eMode_Read ) {
  267.         m_FileStream = fopen(file_name.c_str(), "rb");
  268.         m_File = BZ2_bzReadOpen (&errcode, m_FileStream, m_SmallDecompress,
  269.                                  m_Verbosity, 0, 0);
  270.         m_EOF = false;
  271.     } else {
  272.         m_FileStream = fopen(file_name.c_str(), "wb");
  273.         m_File = BZ2_bzWriteOpen(&errcode, m_FileStream, GetLevel(),
  274.                                  m_Verbosity, m_WorkFactor);
  275.     }
  276.     m_Mode = mode;
  278.     if ( errcode != BZ_OK ) {
  279.         Close();
  280.         SetError(errcode, GetBZip2ErrorDescription(errcode));
  281.         ERR_POST(FormatErrorMessage("CBZip2CompressionFile::Open", false));
  282.         return false;
  283.     };
  284.     SetError(BZ_OK);
  285.     return true;
  286. } 
  289. int CBZip2CompressionFile::Read(void* buf, int len)
  290. {
  291.     if ( m_EOF ) {
  292.         return 0;
  293.     }
  294.     int errcode;
  295.     int nread = BZ2_bzRead(&errcode, m_File, buf, len);
  296.     SetError(errcode, GetBZip2ErrorDescription(errcode));
  298.     if ( errcode != BZ_OK  &&  errcode != BZ_STREAM_END ) {
  299.         ERR_POST(FormatErrorMessage("CBZip2CompressionFile::Read", false));
  300.         return -1;
  301.     }; 
  302.     if ( errcode == BZ_STREAM_END ) {
  303.         m_EOF = true;
  304.     }; 
  305.     return nread;
  306. }
  309. int CBZip2CompressionFile::Write(const void* buf, int len)
  310. {
  311.     int errcode;
  312.     BZ2_bzWrite(&errcode, m_File, const_cast<void*>(buf), len);
  313.     SetError(errcode, GetBZip2ErrorDescription(errcode));
  315.     if ( errcode != BZ_OK  &&  errcode != BZ_STREAM_END ) {
  316.         ERR_POST(FormatErrorMessage("CBZip2CompressionFile::Write", false));
  317.         return -1;
  318.     }; 
  319.     return len;
  320.  
  321. }
  324. bool CBZip2CompressionFile::Close(void)
  325. {
  326.     int errcode = BZ_OK;
  328.     if ( m_File ) {
  329.         if ( m_Mode == eMode_Read ) {
  330.             BZ2_bzReadClose(&errcode, m_File);
  331.             m_EOF = true;
  332.         } else {
  333.             BZ2_bzWriteClose(&errcode, m_File, 0, 0, 0);
  334.         }
  335.         m_File = 0;
  336.     }
  337.     SetError(errcode, GetBZip2ErrorDescription(errcode));
  339.     if ( m_FileStream ) {
  340.         fclose(m_FileStream);
  341.         m_FileStream = 0;
  342.     }
  344.     if ( errcode != BZ_OK ) {
  345.         ERR_POST(FormatErrorMessage("CBZip2CompressionFile::Close", false));
  346.         return false;
  347.     }; 
  348.     return true;
  349. }
  353. //////////////////////////////////////////////////////////////////////////////
  354. //
  355. // CBZip2Compressor
  356. //
  359. CBZip2Compressor::CBZip2Compressor(
  360.                   ELevel level, int verbosity, int work_factor)
  361.     : CBZip2Compression(level, verbosity, work_factor, 0)
  362. {
  363. }
  366. CBZip2Compressor::~CBZip2Compressor()
  367. {
  368. }
  371. CCompressionProcessor::EStatus CBZip2Compressor::Init(void)
  372. {
  373.     // Initialize members
  374.     Reset();
  375.     SetBusy();
  376.     // Initialize the compressor stream structure
  377.     memset(&m_Stream, 0, sizeof(m_Stream));
  378.     // Create a compressor stream
  379.     int errcode = BZ2_bzCompressInit(&m_Stream, GetLevel(), m_Verbosity,
  380.                                      m_WorkFactor);
  381.     SetError(errcode, GetBZip2ErrorDescription(errcode));
  383.     if ( errcode == BZ_OK ) {
  384.         return eStatus_Success;
  385.     }
  386.     ERR_POST(FormatErrorMessage("CBZip2Compressor::Init"));
  387.     return eStatus_Error;
  388. }
  391. CCompressionProcessor::EStatus CBZip2Compressor::Process(
  392.                       const char* in_buf,  unsigned long  in_len,
  393.                       char*       out_buf, unsigned long  out_size,
  394.                       /* out */            unsigned long* in_avail,
  395.                       /* out */            unsigned long* out_avail)
  396. {
  397.     m_Stream.next_in   = const_cast<char*>(in_buf);
  398.     m_Stream.avail_in  = in_len;
  399.     m_Stream.next_out  = out_buf;
  400.     m_Stream.avail_out = out_size;
  402.     int errcode = BZ2_bzCompress(&m_Stream, BZ_RUN);
  403.     SetError(errcode, GetBZip2ErrorDescription(errcode));
  404.     *in_avail  = m_Stream.avail_in;
  405.     *out_avail = out_size - m_Stream.avail_out;
  406.     IncreaseProcessedSize(in_len - *in_avail);
  407.     IncreaseOutputSize(*out_avail);
  409.     if ( errcode == BZ_RUN_OK ) {
  410.         return eStatus_Success;
  411.     }
  412.     ERR_POST(FormatErrorMessage("CBZip2Compressor::Process"));
  413.     return eStatus_Error;
  414. }
  417. CCompressionProcessor::EStatus CBZip2Compressor::Flush(
  418.                       char* out_buf, unsigned long  out_size,
  419.                       /* out */      unsigned long* out_avail)
  420. {
  421.     if ( !out_size ) {
  422.         return eStatus_Overflow;
  423.     }
  424.     m_Stream.next_in   = 0;
  425.     m_Stream.avail_in  = 0;
  426.     m_Stream.next_out  = out_buf;
  427.     m_Stream.avail_out = out_size;
  429.     int errcode = BZ2_bzCompress(&m_Stream, BZ_FLUSH);
  430.     SetError(errcode, GetBZip2ErrorDescription(errcode));
  431.     *out_avail = out_size - m_Stream.avail_out;
  432.     IncreaseOutputSize(*out_avail);
  434.     if ( errcode == BZ_RUN_OK ) {
  435.         return eStatus_Success;
  436.     } else 
  437.     if ( errcode == BZ_FLUSH_OK ) {
  438.         return eStatus_Overflow;
  439.     }
  440.     ERR_POST(FormatErrorMessage("CBZip2Compressor::Flush"));
  441.     return eStatus_Error;
  442. }
  445. CCompressionProcessor::EStatus CBZip2Compressor::Finish(
  446.                       char* out_buf, unsigned long  out_size,
  447.                       /* out */      unsigned long* out_avail)
  448. {
  449.     if ( !out_size ) {
  450.         return eStatus_Overflow;
  451.     }
  452.     m_Stream.next_in   = 0;
  453.     m_Stream.avail_in  = 0;
  454.     m_Stream.next_out  = out_buf;
  455.     m_Stream.avail_out = out_size;
  457.     int errcode = BZ2_bzCompress(&m_Stream, BZ_FINISH);
  458.     SetError(errcode, GetBZip2ErrorDescription(errcode));
  459.     *out_avail = out_size - m_Stream.avail_out;
  460.     IncreaseOutputSize(*out_avail);
  462.     switch (errcode) {
  463.     case BZ_FINISH_OK:
  464.         return eStatus_Overflow;
  465.     case BZ_STREAM_END:
  466.         return eStatus_EndOfData;
  467.     }
  468.     ERR_POST(FormatErrorMessage("CBZip2Compressor::Finish"));
  469.     return eStatus_Error;
  470. }
  473. CCompressionProcessor::EStatus CBZip2Compressor::End(void)
  474. {
  475.     int errcode = BZ2_bzCompressEnd(&m_Stream);
  476.     SetError(errcode, GetBZip2ErrorDescription(errcode));
  477.     SetBusy(false);
  479.     if ( errcode == BZ_OK ) {
  480.         return eStatus_Success;
  481.     }
  482.     ERR_POST(FormatErrorMessage("CBZip2Compressor::End"));
  483.     return eStatus_Error;
  484. }
  488. //////////////////////////////////////////////////////////////////////////////
  489. //
  490. // CBZip2Decompressor
  491. //
  494. CBZip2Decompressor::CBZip2Decompressor(int verbosity, int small_decompress)
  495.     : CBZip2Compression(eLevel_Default, verbosity, 0, small_decompress)
  496. {
  497. }
  500. CBZip2Decompressor::~CBZip2Decompressor()
  501. {
  502. }
  505. CCompressionProcessor::EStatus CBZip2Decompressor::Init(void)
  506. {
  507.     // Initialize members
  508.     Reset();
  509.     SetBusy();
  510.     // Initialize the decompressor stream structure
  511.     memset(&m_Stream, 0, sizeof(m_Stream));
  512.     // Create a compressor stream
  513.     int errcode = BZ2_bzDecompressInit(&m_Stream, m_Verbosity,
  514.                                        m_SmallDecompress);
  515.     SetError(errcode, GetBZip2ErrorDescription(errcode));
  517.     if ( errcode == BZ_OK ) {
  518.         return eStatus_Success;
  519.     }
  520.     ERR_POST(FormatErrorMessage("CBZip2Decompressor::Init"));
  521.     return eStatus_Error;
  522. }
  525. CCompressionProcessor::EStatus CBZip2Decompressor::Process(
  526.                       const char* in_buf,  unsigned long  in_len,
  527.                       char*       out_buf, unsigned long  out_size,
  528.                       /* out */            unsigned long* in_avail,
  529.                       /* out */            unsigned long* out_avail)
  530. {
  531.     if ( !out_size ) {
  532.         return eStatus_Overflow;
  533.     }
  534.     m_Stream.next_in   = const_cast<char*>(in_buf);
  535.     m_Stream.avail_in  = in_len;
  536.     m_Stream.next_out  = out_buf;
  537.     m_Stream.avail_out = out_size;
  539.     int errcode = BZ2_bzDecompress(&m_Stream);
  540.     SetError(errcode, GetBZip2ErrorDescription(errcode));
  542.     *in_avail  = m_Stream.avail_in;
  543.     *out_avail = out_size - m_Stream.avail_out;
  544.     IncreaseProcessedSize(in_len - *in_avail);
  545.     IncreaseOutputSize(*out_avail);
  547.     switch (errcode) {
  548.     case BZ_OK:
  549.         return eStatus_Success;
  550.     case BZ_STREAM_END:
  551.         return eStatus_EndOfData;
  552.     }
  553.     ERR_POST(FormatErrorMessage("CBZip2Decompressor::Process"));
  554.     return eStatus_Error;
  555. }
  558. CCompressionProcessor::EStatus CBZip2Decompressor::Flush(
  559.                       char*, unsigned long, unsigned long*)
  560. {
  561.     return eStatus_Success;
  562. }
  565. CCompressionProcessor::EStatus CBZip2Decompressor::Finish(
  566.                       char*, unsigned long, unsigned long*)
  567. {
  568.     return eStatus_Success;
  569. }
  572. CCompressionProcessor::EStatus CBZip2Decompressor::End(void)
  573. {
  574.     int errcode = BZ2_bzDecompressEnd(&m_Stream);
  575.     SetBusy(false);
  576.     if ( errcode == BZ_OK ) {
  577.         return eStatus_Success;
  578.     }
  579.     ERR_POST(FormatErrorMessage("CBZip2Decompressor::End"));
  580.     return eStatus_Error;
  581. }
  584. END_NCBI_SCOPE
  587. /*
  588.  * ===========================================================================
  589.  * $Log: bzip2.cpp,v $
  590.  * Revision 1000.2  2004/06/01 19:40:54  gouriano
  591.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.9
  592.  *
  593.  * Revision 1.9  2004/05/17 21:07:25  gorelenk
  594.  * Added include of PCH ncbi_pch.hpp
  595.  *
  596.  * Revision 1.8  2004/05/10 12:03:18  ivanov
  597.  * The real changes in R1.7 was:
  598.  *     Added calls to increase the number of processed/output bytes.
  599.  *
  600.  * Revision 1.7  2004/05/10 11:56:08  ivanov
  601.  * Added gzip file format support
  602.  *
  603.  * Revision 1.6  2004/04/01 14:14:03  lavr
  604.  * Spell "occurred", "occurrence", and "occurring"
  605.  *
  606.  * Revision 1.5  2003/07/15 15:46:31  ivanov
  607.  * Improved error diagnostics. Save status codes and it's description after
  608.  * each compression operation, and ERR_POST it if error occurred.
  609.  *
  610.  * Revision 1.4  2003/07/10 16:26:23  ivanov
  611.  * Implemented CompressFile/DecompressFile functions.
  612.  *
  613.  * Revision 1.3  2003/06/17 15:43:58  ivanov
  614.  * Minor cosmetics and comments changes
  615.  *
  616.  * Revision 1.2  2003/06/03 20:09:16  ivanov
  617.  * The Compression API redesign. Added some new classes, rewritten old.
  618.  *
  619.  * Revision 1.1  2003/04/07 20:21:35  ivanov
  620.  * Initial revision
  621.  *
  622.  * ===========================================================================
  623.  */