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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 压缩解压 > 查看源码
CompressedFile.cpp
资源名称：compress.rar　[点击查看]
上传用户：deer201011
上传日期：2022-06-24
资源大小：10k
文件大小：9k
源码类别：

压缩解压

开发平台：

Visual C++

CompressedFile.cpp：源码内容
  1. // CompressedFile.cpp
  3. #include "CompressedFile.h"
  5. CCompressedFile::CCompressedFile( int nType )
  6. {
  8. m_bOpened = m_bCanRead = m_bCanWrite = FALSE;
  9. m_nCompressionType = nType;
  10. m_pBuffer = NULL;
  12. }
  14. CCompressedFile::~CCompressedFile()
  15. {
  17. if( m_bOpened ) Close();
  18. if( m_pBuffer != NULL ) delete [] m_pBuffer;
  20. }
  22. BOOL CCompressedFile::Open( const char *pszFileName, unsigned int nOpenFlags, CFileException *pError )
  23. {
  25. if( m_pBuffer != NULL ) delete [] m_pBuffer;
  26. m_pBuffer = (unsigned char *) new unsigned char [BUFFERSIZE];
  28. if( m_pBuffer && ( nOpenFlags == CFile::modeRead || nOpenFlags == ( CFile::modeWrite | CFile::modeCreate ) || nOpenFlags == CFile::modeWrite ) ){
  29. if( nOpenFlags == CFile::modeRead || nOpenFlags == CFile::modeWrite) m_nCompressionType = FileType( (char *) pszFileName );
  30. strcpy( m_szFilename, pszFileName );
  31. m_dwCompressedSize = m_dwUncompressedSize = 0L;
  32. m_dwSeekTo = SIGNATURE_LENGTH;
  33. m_nFlags = nOpenFlags;
  34. m_dwBytesInBuffer = m_dwBufferPointer = m_dwFileLength = m_dwFilePointer = 0L;
  35. if( !CFile::Open( pszFileName, nOpenFlags, pError ) ) return( FALSE );
  36. m_dwFileLength = CFile::GetLength();
  37. if( nOpenFlags == CFile::modeWrite ){
  38. m_dwSeekTo = m_dwFilePointer = CFile::SeekToEnd();
  39. CFile::Write( &m_dwUncompressedSize, sizeof( DWORD ) );
  40. CFile::Write( &m_dwCompressedSize, sizeof( DWORD ) );
  41. m_dwFilePointer += 8L;
  42. }
  43. else if( nOpenFlags != ( CFile::modeCreate | CFile::modeWrite ) ){
  44. if( m_nCompressionType >= 0 ){
  45. CFile::Seek( SIGNATURE_LENGTH, CFile::begin );
  46. CFile::Read( &m_dwUncompressedSize, sizeof( DWORD ) );
  47. CFile::Read( &m_dwCompressedSize, sizeof( DWORD ) );
  48. }
  49. else{
  50. m_dwUncompressedSize = m_dwCompressedSize = CFile::GetLength();
  51. }
  52. }
  53. else{
  54. if( m_nCompressionType >= 0 ){
  55. CFile::Write( szSignatures[m_nCompressionType], SIGNATURE_LENGTH );
  56. CFile::Write( &m_dwUncompressedSize, sizeof( DWORD ) );
  57. CFile::Write( &m_dwCompressedSize, sizeof( DWORD ) );
  58. }
  59. }
  60. m_bOpened = TRUE;
  61. if( nOpenFlags == CFile::modeRead ) m_bCanRead = TRUE;
  62. else m_bCanWrite = TRUE;
  63. m_nRack = m_nPacifierCount = 0;
  64. m_nMask = 0x0080;
  65. return( TRUE );
  66. }
  68. if( m_pBuffer != NULL ) delete [] m_pBuffer;
  69. m_pBuffer = NULL;
  70. return( FALSE );
  72. }
  74. void CCompressedFile::Close( void )
  75. {
  77. if( !m_bOpened ) return;
  79. // If a buffer has been allocated, we may have some
  80. // bytes we need to write to disk.
  81. if( m_pBuffer != NULL ){
  82. if( m_dwBytesInBuffer && ( m_nFlags == CFile::modeWrite || m_nFlags == ( CFile::modeWrite | CFile::modeCreate ) )) CFile::Write( m_pBuffer, (unsigned int) m_dwBytesInBuffer );
  83. delete [] m_pBuffer;
  84. m_pBuffer = NULL;
  85. }
  87. CFile::Close();
  89. m_bOpened = FALSE;
  91. }
  93. unsigned int CCompressedFile::ReadBytes( void *lpBuf, unsigned int nCount )
  94. {
  96. if( !m_bOpened || !m_bCanRead ) return( 0 );
  98. if( m_pBuffer != NULL ){
  99. unsigned int nBytesRead = 0;
  101. // We got a void, so we need to point an unsigned
  102. // char pointer to the buffer in order to get the data.
  103. unsigned char *pTransfer = (unsigned char *) lpBuf;
  105. for( unsigned int i=0; i<nCount; i++ ){
  107. // If we have data in the buffer, go to buffer and get it.
  108. if( m_dwBytesInBuffer ){
  109. *pTransfer++ = m_pBuffer[m_dwBufferPointer++];
  110. m_dwBytesInBuffer--;
  111. nBytesRead++;
  112. }
  114. // If there's no data in the buffer, read up to
  115. // BUFFERSIZE bytes from disk and update m_dwBytesInBuffer
  116. else{
  117. DWORD dwBytesLeft = m_dwFileLength - m_dwFilePointer;
  118. if( dwBytesLeft >= BUFFERSIZE ){
  119. m_dwBytesInBuffer = CFile::Read( m_pBuffer, BUFFERSIZE );
  120. m_dwFilePointer += BUFFERSIZE;
  121. m_dwBufferPointer = 0;
  122. }
  123. else{
  124. m_dwBytesInBuffer = CFile::Read( m_pBuffer, (int) dwBytesLeft );
  125. m_dwFilePointer += (DWORD) m_dwBytesInBuffer;
  126. m_dwBufferPointer = 0;
  127. }
  128. // Now that we've read in the data, get the byte.
  129. *pTransfer++ = m_pBuffer[m_dwBufferPointer++];
  130. m_dwBytesInBuffer--;
  131. nBytesRead++;
  132. }
  133. }
  135. return( nBytesRead );
  137. }
  139. return( CFile::Read( lpBuf, nCount ) );
  141. }
  143. int CCompressedFile::ReadByte( void )
  144. {
  145. int nReturnValue;
  146. unsigned char ucData;
  148. if( ReadBytes( &ucData, 1 ) != 1 ) return( -1 );
  149. nReturnValue = (int) ucData;
  150. nReturnValue &= 0x000000ff;
  152. return( nReturnValue );
  154. }
  156. void CCompressedFile::WriteBytes( void *lpBuf, unsigned int nCount )
  157. {
  159. if( !m_bOpened || !m_bCanWrite ) return;
  161. if( m_pBuffer ){
  163. if( m_nCompressionType == -1 ){
  164. m_dwCompressedSize += (DWORD) nCount;
  165. m_dwUncompressedSize += (DWORD) nCount;
  166. }
  168. unsigned char *pTransfer = (unsigned char *) lpBuf;
  170. for( unsigned int i=0; i<nCount; i++ ){
  172. // If there are less than BUFFERSIZE bytes in
  173. // the buffer, just store the next byte in the buffer.
  174. if( m_dwBytesInBuffer < BUFFERSIZE ){
  175. m_pBuffer[m_dwBufferPointer++] = *pTransfer++;
  176. m_dwBytesInBuffer++;
  177. }
  179. // If there are BUFFERSIZE bytes in the buffer
  180. // it's time to write the data to disk before trying to
  181. // put another byte in the buffer.
  182. else{
  183. // Write the data.
  184. CFile::Write( m_pBuffer, BUFFERSIZE );
  185. m_dwFilePointer += BUFFERSIZE;
  186. m_dwFileLength += BUFFERSIZE;
  187. m_dwBytesInBuffer = 0;
  188. m_dwBufferPointer = 0;
  190. // Now store the byte in the buffer.
  191. m_pBuffer[m_dwBufferPointer++] = *pTransfer++;
  192. m_dwBytesInBuffer++;
  193. }
  194. }
  196. return;
  198. }
  200. CFile::Write( lpBuf, nCount );
  202. }
  204. void CCompressedFile::WriteByte( int nByte )
  205. {
  207. unsigned char ucData;
  208. ucData = (unsigned char) nByte;
  209. WriteBytes( &ucData, 1 );
  210. m_dwCompressedSize++;
  212. }
  214. DWORD CCompressedFile::GetPosition( void )
  215. {
  217. return( m_dwFilePointer );
  219. }
  221. DWORD CCompressedFile::GetLength( void )
  222. {
  224. return( m_dwUncompressedSize );
  226. }
  228. int CCompressedFile::FileType( char *pszFilename )
  229. {
  230. char cbSignature[20];
  231. CFile cf;
  233. if( !cf.Open( pszFilename, CFile::modeRead ) ) return( -1 );
  235. if( cf.Read( cbSignature, SIGNATURE_LENGTH ) != SIGNATURE_LENGTH ){
  236. cf.Close();
  237. return( -1 );
  238. }
  240. for( int i=0; i<NUMBER_OF_SIGNATURES; i++ ){
  241. int nMatched = 1;
  242. if( strncmp( cbSignature, szSignatures[i], strlen( szSignatures[i] ) ) )
  243. nMatched = 0;
  244. if( nMatched ) return( i );
  245. }
  247. return( -1 );
  249. }
  251. unsigned int CCompressedFile::Read( void *lpBuf, unsigned int nCount )
  252. {
  254. return( 0 );
  256. }
  258. void CCompressedFile::Write( void *lpBuf, unsigned int nCount )
  259. {
  261. }
  263. void CCompressedFile::OutputBit( int nBit )
  264. {
  266. if( nBit ) m_nRack |= m_nMask;
  267. m_nMask >>= 1;
  269. if( !m_nMask ){
  270. WriteByte( m_nRack );
  271. m_nRack = 0;
  272. m_nMask = 0x0080;
  273. }
  275. }
  277. void CCompressedFile::OutputBits( DWORD dwCode, int nCount )
  278. {
  279. DWORD dwMask;
  281. dwMask = 1L << ( nCount - 1 );
  282. while( dwMask ){
  283. if( dwMask & dwCode ) m_nRack |= m_nMask;
  284. m_nMask >>= 1;
  285. if( !m_nMask ){
  286. WriteByte( m_nRack );
  287. m_nRack = 0;
  288. m_nMask = 0x0080;
  289. }
  290. dwMask >>= 1;
  291. }
  293. }
  295. int CCompressedFile::InputBit( void )
  296. {
  297. int nValue;
  299. if( m_nMask == 0x0080 ) m_nRack = ReadByte();
  301. nValue = m_nRack & m_nMask;
  302. m_nMask >>= 1;
  303. if( !m_nMask ) m_nMask = 0x0080;
  305. return( nValue ? 1 : 0 );
  307. }
  309. DWORD CCompressedFile::InputBits( int nCount )
  310. {
  311. DWORD dwMask, dwReturnValue = 0;
  313. dwMask = 1L << ( nCount - 1 );
  314. while( dwMask ){
  315. if( m_nMask == 0x0080 ) m_nRack = ReadByte();
  316. if( m_nRack & m_nMask ) dwReturnValue |= dwMask;
  317. dwMask >>= 1;
  318. m_nMask >>= 1;
  319. if( !m_nMask ) m_nMask = 0x0080;
  320. }
  322. return( dwReturnValue );
  324. }
  326. BOOL CCompressedFile::FindFileInArchive( int nIndex )
  327. {
  329. if( !m_bOpened || m_nFlags != CFile::modeRead ) return( FALSE );
  331. DWORD dwPosition = CFile::GetPosition();
  332. DWORD dwLength = CFile::GetLength();
  333. CFile::Seek( SIGNATURE_LENGTH, CFile::begin );
  334. BOOL bDone = FALSE;
  335. int nCounter = 0;
  337. while( !bDone ){
  338. DWORD dwUncompressed, dwCompressed;
  339. CFile::Read( &dwUncompressed, sizeof( DWORD ) );
  340. CFile::Read( &dwCompressed, sizeof( DWORD ) );
  341. if( nCounter == nIndex ){
  342. m_dwUncompressedSize = dwUncompressed;
  343. m_dwCompressedSize = dwCompressed;
  344. m_dwFilePointer = m_dwSeekTo = CFile::GetPosition();
  345. m_dwSeekTo -= 8L;
  346. m_nRack = m_nPacifierCount = 0;
  347. m_nMask = 0x0080;
  348. m_dwBytesInBuffer = m_dwBufferPointer = 0L;
  349. return( TRUE );
  350. }
  351. nCounter++;
  352. CFile::Seek( dwCompressed, CFile::current );
  353. if( CFile::GetPosition () >= dwLength ) bDone = 1;
  354. }
  356. CFile::Seek( dwPosition, CFile::begin );
  358. return( FALSE );
  360. }
  362. CCompressedFile *CCompressedFile::MakeNewFile( char *pszFilename, int nTyp )
  363. {
  364. int nType;
  365. if( pszFilename && pszFilename[0] ) nType = FileType( pszFilename );
  366. else nType = nTyp;
  368. switch( nType ){
  369. case HUFF:
  370. return( new CHuffmanFile );
  371. break;
  372. case LZSS:
  373. return( new CLzssFile );
  374. break;
  375. case LZW:
  376. return( new CLzwFile );
  377. break;
  378. default:
  379. return( new CUncompressedFile );
  380. }
  382. return( NULL );
  384. }
  386. void CCompressedFile::SetSizeToFileLength( void )
  387. {
  389. m_dwUncompressedSize = m_dwFileLength;
  391. }