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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 远程控制编程 > 查看源码
PeeperZip.cpp
资源名称：TOUKUI-1.5.zip　[点击查看]
上传用户：xztxsm
上传日期：2007-02-12
资源大小：150k
文件大小：38k
源码类别：

远程控制编程

开发平台：

Visual C++

PeeperZip.cpp：源码内容
  1. ///////////////////////////////////////////////////////////////////////////////
  2. // 远程控制软件-偷窥者  压缩库                                               //
  3. // 日期:2001/10/02                                                           //
  4. // 作者:刘东发                                                               //
  5. // Email:dongfa@yeah.net                                                     //
  6. // http://dongfa.yeah.net                                                    //
  7. // OICQ:5584173  阿东                                                        //
  8. // 作者声明:                                                                 //
  9. //     此部分代码是从网上下载获得，经过本人的改写， 变得容易使用，希望能给   //
  10. // 大家带来方便.                                                             //
  11. ///////////////////////////////////////////////////////////////////////////////
  13. #include "stdafx.h"
  14. #include "PeeperZip.h"
  16. ///////////////////////////////////////////////////////////////////////////////
  17. //LZ77 Part START--------------------------------------------------------------
  18. ///////////////////////////////////////////////////////////////////////////////
  19. int CCompress::UpperLog2(int n)
  20. {
  21. int i = 0;
  22. if (n > 0)
  23. {
  24. int m = 1;
  25. while(1)
  26. {
  27. if (m >= n)
  28. return i;
  29. m <<= 1;
  30. i++;
  31. }
  32. }
  33. else 
  34. return -1;
  35. }
  37. int CCompress::LowerLog2(int n)
  38. {
  39. int i = 0;
  40. if (n > 0)
  41. {
  42. int m = 1;
  43. while(1)
  44. {
  45. if (m == n)
  46. return i;
  47. if (m > n)
  48. return i - 1;
  49. m <<= 1;
  50. i++;
  51. }
  52. }
  53. else 
  54. return -1;
  55. }
  57. void CCompress::MovePos(int* piByte, int* piBit, int num)
  58. {
  59. num += (*piBit);
  60. (*piByte) += num / 8;
  61. (*piBit) = num % 8;
  62. }
  64. BYTE CCompress::GetBit(BYTE byte, int pos)
  65. {
  66. int j = 1;
  67. j <<= 7 - pos;
  68. if (byte & j)
  69. return 1;
  70. else 
  71. return 0;
  72. }
  74. void CCompress::SetBit(BYTE* byte, int iBit, BYTE aBit)
  75. {
  76. if (aBit)
  77. (*byte) |= (1 << (7 - iBit));
  78. else
  79. (*byte) &= ~(1 << (7 - iBit));
  80. }
  82. void CCompress::InvertDWord(DWORD* pDW)
  83. {
  84. union UDWORD{ DWORD dw; BYTE b[4]; };
  85. UDWORD* pUDW = (UDWORD*)pDW;
  86. BYTE b;
  87. b = pUDW->b[0]; pUDW->b[0] = pUDW->b[3]; pUDW->b[3] = b;
  88. b = pUDW->b[1]; pUDW->b[1] = pUDW->b[2]; pUDW->b[2] = b;
  89. }
  91. void CCompress::CopyBits(BYTE* memDest, int nDestPos, 
  92.   BYTE* memSrc, int nSrcPos, int nBits)
  93. {
  94. int iByteDest = 0, iBitDest;
  95. int iByteSrc = 0, iBitSrc = nSrcPos;
  97. int nBitsToFill, nBitsCanFill;
  99. while (nBits > 0)
  100. {
  101. nBitsToFill = min(nBits, iByteDest ? 8 : 8 - nDestPos);
  102. iBitDest = iByteDest ? 0 : nDestPos;
  103. nBitsCanFill = min(nBitsToFill, 8 - iBitSrc);
  104. CopyBitsInAByte(memDest + iByteDest, iBitDest, 
  105. memSrc + iByteSrc, iBitSrc, nBitsCanFill);
  106. if (nBitsToFill > nBitsCanFill)
  107. {
  108. iByteSrc++; iBitSrc = 0; iBitDest += nBitsCanFill;
  109. CopyBitsInAByte(memDest + iByteDest, iBitDest, 
  110. memSrc + iByteSrc, iBitSrc, 
  111. nBitsToFill - nBitsCanFill);
  112. iBitSrc += nBitsToFill - nBitsCanFill;
  113. }
  114. else 
  115. {
  116. iBitSrc += nBitsCanFill;
  117. if (iBitSrc >= 8)
  118. {
  119. iByteSrc++; iBitSrc = 0;
  120. }
  121. }
  123. nBits -= nBitsToFill;
  124. iByteDest++;
  125. }
  126. }
  128. void CCompress::CopyBitsInAByte(BYTE* memDest, int nDestPos, 
  129.   BYTE* memSrc, int nSrcPos, int nBits)
  130. {
  131. BYTE b1, b2;
  132. b1 = *memSrc;
  133. b1 <<= nSrcPos; b1 >>= 8 - nBits;
  134. b1 <<= 8 - nBits - nDestPos;
  135. *memDest |= b1;
  136. b2 = 0xff; b2 <<= 8 - nDestPos;
  137. b1 |= b2;
  138. b2 = 0xff; b2 >>= nDestPos + nBits;
  139. b1 |= b2;
  140. *memDest &= b1;
  141. }
  143. CCompressLZ77::CCompressLZ77()
  144. {
  145. SortHeap = new struct STIDXNODE[_MAX_WINDOW_SIZE];
  146. }
  148. CCompressLZ77::~CCompressLZ77()
  149. {
  150. delete[] SortHeap;
  151. }
  153. void CCompressLZ77::_InitSortTable()
  154. {
  155. memset(SortTable, 0, sizeof(WORD) * 65536);
  156. nWndSize = 0;
  157. HeapPos = 1;
  158. }
  160. void CCompressLZ77::_InsertIndexItem(int off)
  161. {
  162. WORD q;
  163. BYTE ch1, ch2;
  164. ch1 = pWnd[off]; ch2 = pWnd[off + 1];
  166. if (ch1 != ch2)
  167. {
  168. q = HeapPos;
  169. HeapPos++;
  170. SortHeap[q].off = off;
  171. SortHeap[q].next = SortTable[ch1 * 256 + ch2];
  172. SortTable[ch1 * 256 + ch2] = q;
  173. }
  174. else
  175. {
  176. q = SortTable[ch1 * 256 + ch2];
  177. if (q != 0 && off == SortHeap[q].off2 + 1)
  178. {
  179. SortHeap[q].off2 = off;
  180. }
  181. else
  182. {
  183. q = HeapPos;
  184. HeapPos++;
  185. SortHeap[q].off = off;
  186. SortHeap[q].off2 = off;
  187. SortHeap[q].next = SortTable[ch1 * 256 + ch2];
  188. SortTable[ch1 * 256 + ch2] = q;
  189. }
  190. }
  191. }
  193. void CCompressLZ77::_ScrollWindow(int n)
  194. {
  195. for (int i = 0; i < n; i++)
  196. {
  197. nWndSize++;
  198. if (nWndSize > 1)
  199. _InsertIndexItem(nWndSize - 2);
  200. }
  201. }
  203. int CCompressLZ77::_GetSameLen(BYTE* src, int srclen, int nSeekStart, int offset)
  204. {
  205. int i = 2;
  206. int maxsame = min(srclen - nSeekStart, nWndSize - offset);
  207. while (i < maxsame
  208. && src[nSeekStart + i] == pWnd[offset + i])
  209. i++;
  210. _ASSERT(nSeekStart + i <= srclen && offset + i <= nWndSize);
  211. return i;
  212. }
  214. BOOL CCompressLZ77::_SeekPhase(BYTE* src, int srclen, int nSeekStart, int* offset, int* len)
  215. {
  216. int j, m, n;
  218. if (nSeekStart < srclen - 1)
  219. {
  220. BYTE ch1, ch2;
  221. ch1 = src[nSeekStart]; ch2 = src[nSeekStart + 1];
  222. WORD p;
  223. p = SortTable[ch1 * 256 + ch2];
  224. if (p != 0)
  225. {
  226. m = 2; n = SortHeap[p].off;
  227. while (p != 0)
  228. {
  229. j = _GetSameLen(src, srclen, 
  230. nSeekStart, SortHeap[p].off);
  231. if ( j > m )
  232. { 
  233. m = j; 
  234. n = SortHeap[p].off;
  235. }
  236. p = SortHeap[p].next;
  237. }
  238. (*offset) = n; 
  239. (*len) = m;
  240. return TRUE;
  241. }
  242. }
  243. return FALSE;
  244. }
  246. void CCompressLZ77::_OutCode(BYTE* dest, DWORD code, int bits, BOOL isGamma)
  247. {
  248. if ( isGamma )
  249. {
  250. BYTE* pb;
  251. DWORD out;
  252. int GammaCode = (int)code - 1;
  253. int q = LowerLog2(GammaCode);
  254. if (q > 0)
  255. {
  256. out = 0xffff;
  257. pb = (BYTE*)&out;
  258. CopyBits(dest + CurByte, CurBit, 
  259. pb, 0, q);
  260. MovePos(&CurByte, &CurBit, q);
  261. }
  262. out = 0;
  263. pb = (BYTE*)&out;
  264. CopyBits(dest + CurByte, CurBit, pb + 3, 7, 1);
  265. MovePos(&CurByte, &CurBit, 1);
  266. if (q > 0)
  267. {
  268. int sh = 1;
  269. sh <<= q;
  270. out = GammaCode - sh;
  271. pb = (BYTE*)&out;
  272. InvertDWord(&out);
  273. CopyBits(dest + CurByte, CurBit, 
  274. pb + (32 - q) / 8, (32 - q) % 8, q);
  275. MovePos(&CurByte, &CurBit, q);
  276. }
  277. }
  278. else 
  279. {
  280. DWORD dw = (DWORD)code;
  281. BYTE* pb = (BYTE*)&dw;
  282. InvertDWord(&dw);
  283. CopyBits(dest + CurByte, CurBit, 
  284. pb + (32 - bits) / 8, (32 - bits) % 8, bits);
  285. MovePos(&CurByte, &CurBit, bits);
  286. }
  287. }
  289. int CCompressLZ77::Compress(BYTE* src, int srclen, BYTE* dest)
  290. {
  291. int i;
  292. CurByte = 0; CurBit = 0;
  293. int off, len;
  295. if (srclen > 65536) 
  296. return -1;
  298. pWnd = src;
  299. _InitSortTable();
  300. for (i = 0; i < srclen; i++)
  301. {
  302. if (CurByte >= srclen)
  303. return 0;
  304. if (_SeekPhase(src, srclen, i, &off, &len))
  305. {
  306. _OutCode(dest, 1, 1, FALSE);
  307. _OutCode(dest, len, 0, TRUE);
  309. _OutCode(dest, off, UpperLog2(nWndSize), FALSE);
  311. _ScrollWindow(len);
  312. i += len - 1;
  313. }
  314. else
  315. {
  316. _OutCode(dest, 0, 1, FALSE);
  317. _OutCode(dest, (DWORD)(src[i]), 8, FALSE);
  318. _ScrollWindow(1);
  319. }
  320. }
  321. int destlen = CurByte + ((CurBit) ? 1 : 0);
  322. if (destlen >= srclen)
  323. return 0;
  324. return destlen;
  325. }
  327. BOOL CCompressLZ77::Decompress(BYTE* src, int srclen, BYTE* dest)
  328. {
  329. int i;
  330. CurByte = 0; CurBit = 0;
  331. pWnd = src; // 初始化窗口
  332. nWndSize = 0;
  334. if (srclen > 65536) 
  335. return FALSE;
  337. for (i = 0; i < srclen; i++)
  338. {
  339. BYTE b = GetBit(dest[CurByte], CurBit);
  340. MovePos(&CurByte, &CurBit, 1);
  341. if (b == 0) // 单个字符
  342. {
  343. CopyBits(src + i, 0, dest + CurByte, CurBit, 8);
  344. MovePos(&CurByte, &CurBit, 8);
  345. nWndSize++;
  346. }
  347. else // 窗口内的术语
  348. {
  349. int q = -1;
  350. while (b != 0)
  351. {
  352. q++;
  353. b = GetBit(dest[CurByte], CurBit);
  354. MovePos(&CurByte, &CurBit, 1);
  355. }
  356. int len, off;
  357. DWORD dw = 0;
  358. BYTE* pb;
  359. if (q > 0)
  360. {
  361. pb = (BYTE*)&dw;
  362. CopyBits(pb + (32 - q) / 8, (32 - q) % 8, dest + CurByte, CurBit, q);
  363. MovePos(&CurByte, &CurBit, q);
  364. InvertDWord(&dw);
  365. len = 1;
  366. len <<= q;
  367. len += dw;
  368. len += 1;
  369. }
  370. else
  371. len = 2;
  373. dw = 0;
  374. pb = (BYTE*)&dw;
  375. int bits = UpperLog2(nWndSize);
  376. CopyBits(pb + (32 - bits) / 8, (32 - bits) % 8, dest + CurByte, CurBit, bits);
  377. MovePos(&CurByte, &CurBit, bits);
  378. InvertDWord(&dw);
  379. off = (int)dw;
  380. for (int j = 0; j < len; j++)
  381. {
  382. _ASSERT(i + j <  srclen);
  383. _ASSERT(off + j <  _MAX_WINDOW_SIZE);
  385. src[i + j] = pWnd[off + j];
  386. }
  387. nWndSize += len;
  388. i += len - 1;
  389. }
  390. if (nWndSize > _MAX_WINDOW_SIZE)
  391. {
  392. pWnd += nWndSize - _MAX_WINDOW_SIZE;
  393. nWndSize = _MAX_WINDOW_SIZE;
  394. }
  395. }
  397. return TRUE;
  398. }
  399. ///////////////////////////////////////////////////////////////////////////////
  400. //LZ77 Part END--------------------------------------------------------------
  401. ///////////////////////////////////////////////////////////////////////////////
  403. ///////////////////////////////////////////////////////////////////////////////
  404. //LZSS Part START--------------------------------------------------------------
  405. ///////////////////////////////////////////////////////////////////////////////
  407. HGLOBAL C_LZSS::Encode(char *chData, int nSize)
  408. {
  409. if(!AfxIsValidAddress(chData, nSize))
  410. return NULL;
  412. //缓冲数据区大小
  413. const int nMaxSize = 65536;
  415. HGLOBAL hZip = NULL;
  416. hZip = ::GlobalAlloc(GHND, nMaxSize);
  417. if(hZip == NULL)
  418. {
  419. return NULL;
  420. }
  421. LPBYTE lpZipData = (LPBYTE)::GlobalLock(hZip);
  422. BYTE byMaxBuf[nMaxSize];
  423. ZeroMemory(byMaxBuf, nMaxSize);
  425. int nCurPos = 0; //记下数据的位置
  427. int nZipPos = 0; //记下压缩数据的位置
  428. int nBufPos = 0; //记下当前存储位置hZip
  429. int nZipSize = 0; //压缩后数据的大小
  431. int  i, c, len, r, s, last_match_length, code_buf_ptr;
  432. unsigned char code_buf[17], mask;
  433. InitTree();
  434. code_buf[0] = 0;
  435. code_buf_ptr = mask = 1;
  436. s = 0;  r = LZSS_N - LZSS_F;
  437. for(i = s; i < r; i++)
  438. {
  439. text_buf[i] = ' ';
  440. }
  441. for(len = 0; len < LZSS_F && (nCurPos < nSize/*getc(infile)*/); len++)
  442. {
  443. c = chData[nCurPos]; //add
  444. nCurPos ++; //add
  445. text_buf[r + len] = c;
  446. }
  447. if((textsize = len) == 0)
  448. {
  449. return false;
  450. }
  451. for(i = 1; i <= LZSS_F; i++)
  452. {
  453. InsertNode(r - i);
  454. }
  455. InsertNode(r);
  456. do
  457. {
  458. if(match_length > len)
  459. {
  460. match_length = len;
  461. }
  462. if(match_length <= LZSS_THRESHOLD)
  463. {
  464. match_length = 1;
  465. code_buf[0] |= mask;
  466. code_buf[code_buf_ptr++] = text_buf[r];
  467. }
  468. else
  469. {
  470. code_buf[code_buf_ptr++] = (unsigned char) match_position;
  471. code_buf[code_buf_ptr++] = (unsigned char)
  472. (((match_position >> 4) & 0xf0)
  473.   | (match_length - (LZSS_THRESHOLD + 1)));
  474. }
  475. if((mask <<= 1) == 0)
  476. {
  477. for(i = 0; i < code_buf_ptr; i++)
  478. {
  479. //存储这个压缩字节
  480. if(nZipPos >= nMaxSize)
  481. {
  482. nZipPos = 0;
  483. memcpy(lpZipData + nBufPos, byMaxBuf, nMaxSize);
  484. nBufPos += nMaxSize;
  486. ::GlobalUnlock(hZip); //重新分配内存
  487. hZip = ::GlobalReAlloc(hZip, nBufPos + nMaxSize, 0);
  488. lpZipData = (LPBYTE)::GlobalLock(hZip);
  489. }
  490. byMaxBuf[nZipPos] = code_buf[i];
  491. nZipPos ++;
  492. nZipSize ++; //当前压缩数据的大小
  493. }
  494. codesize += code_buf_ptr;
  495. code_buf[0] = 0;
  496. code_buf_ptr = mask = 1;
  497. }
  498. last_match_length = match_length;
  499. for(i = 0; i < last_match_length && (nCurPos < nSize)/*c = getc(infile)) != EOF*/; i++)
  500. {
  501. c = chData[nCurPos]; //add
  502. nCurPos ++; //add
  503. DeleteNode(s);
  504. text_buf[s] = c;
  505. if(s < LZSS_F - 1)
  506. {
  507. text_buf[s + LZSS_N] = c;
  508. }
  509. s = (s + 1) & (LZSS_N - 1);
  510. r = (r + 1) & (LZSS_N - 1);
  511. InsertNode(r);
  512. }
  513. if((textsize += i) > printcount)
  514. {
  515. printcount += 1024;
  516. }
  517. while(i++ < last_match_length)
  518. {
  519. DeleteNode(s);
  520. s = (s + 1) & (LZSS_N - 1);
  521. r = (r + 1) & (LZSS_N - 1);
  522. if(--len)
  523. {
  524. InsertNode(r);
  525. }
  526. }
  527. }while (len > 0);
  528. if(code_buf_ptr > 1)
  529. {
  530. for(i = 0; i < code_buf_ptr; i++)
  531. {
  532. //存储这个压缩字节
  533. if(nZipPos >= nMaxSize)
  534. {
  535. nZipPos = 0;
  536. memcpy(lpZipData + nBufPos, byMaxBuf, nMaxSize);
  537. nBufPos += nMaxSize;
  539. ::GlobalUnlock(hZip); //重新分配内存
  540. hZip = ::GlobalReAlloc(hZip, nBufPos + nMaxSize, 0);
  541. lpZipData = (LPBYTE)::GlobalLock(hZip);
  542. }
  543. byMaxBuf[nZipPos] = code_buf[i];
  544. nZipPos ++;
  545. nZipSize ++; //当前压缩数据的大小
  546. }
  547. codesize += code_buf_ptr;
  548. }
  549. //存储剩余的压缩数据
  550. if(nZipPos > 0)
  551. {
  552. memcpy(lpZipData + nBufPos, byMaxBuf, nZipPos);
  553. }
  554. ::GlobalUnlock(hZip); //重新分配内存
  555. hZip = ::GlobalReAlloc(hZip, nZipSize, 0);
  556. return hZip;
  557. }
  559. HGLOBAL C_LZSS::Decode(char *chZipData, int nZipSize)
  560. {
  561. if(!AfxIsValidAddress(chZipData, nZipSize))
  562. return NULL;
  564. //缓冲数据区大小
  565. const int nMaxSize = 65536;
  567. HGLOBAL hUnZip = NULL;
  568. hUnZip = ::GlobalAlloc(GHND, nMaxSize);
  569. if(hUnZip == NULL)
  570. {
  571. return NULL;
  572. }
  573. LPBYTE lpUnZipData = (LPBYTE)::GlobalLock(hUnZip);
  574. BYTE byMaxBuf[nMaxSize];
  575. ZeroMemory(byMaxBuf, nMaxSize);
  577. int nCurPos = 0; //记下数据的位置
  579. int nPos = 0; //记下解压数据的位置
  580. int nBufPos = 0; //记下当前存储位置hUnZip
  581. int nSize = 0; //解压后数据的大小
  583. int  i, j, k, r, c;
  584. unsigned char cc; //add
  585. unsigned int  flags;
  586. for (i = 0; i < LZSS_N - LZSS_F; i++)
  587. {
  588. text_buf[i] = ' ';
  589. }
  590. r = LZSS_N - LZSS_F;
  591. flags = 0;
  592. for( ; ; )
  593. {
  594. if(((flags >>= 1) & 256) == 0)
  595. {
  596. if(nCurPos >= nZipSize)//(c = getc(infile)) == EOF)
  597. {
  598. break;
  599. }
  600. c = (unsigned char)chZipData[nCurPos]; //add
  601. nCurPos ++; //add
  603. flags = c | 0xff00;
  604. }
  605. if(flags & 1)
  606. {
  607. if(nCurPos >= nZipSize)//(c = getc(infile)) == EOF)
  608. {
  609. break;
  610. }
  611. c = (unsigned char)chZipData[nCurPos]; //add
  612. cc = c; //add
  613. nCurPos ++; //add
  615. //存储这个压缩字节
  616. if(nPos >= nMaxSize)
  617. {
  618. nPos = 0;
  619. memcpy(lpUnZipData + nBufPos, byMaxBuf, nMaxSize);
  620. nBufPos += nMaxSize;
  622. ::GlobalUnlock(hUnZip); //重新分配内存
  623. hUnZip = ::GlobalReAlloc(hUnZip, nBufPos + nMaxSize, 0);
  624. lpUnZipData = (LPBYTE)::GlobalLock(hUnZip);
  625. }
  626. byMaxBuf[nPos] = cc;
  627. nPos ++;
  628. nSize ++; //当前压缩数据的大小
  630. text_buf[r++] = c;
  631. r &= (LZSS_N - 1);
  632. }
  633. else
  634. {
  635. if(nCurPos >= nZipSize)//(i = getc(infile)) == EOF)
  636. {
  637. break;
  638. }
  639. i = (unsigned char)chZipData[nCurPos]; //add
  640. nCurPos ++; //add
  642. if(nCurPos >= nZipSize)//(j = getc(infile)) == EOF)
  643. {
  644. break;
  645. }
  646. j = chZipData[nCurPos]; //add
  647. nCurPos ++; //add
  649. i |= ((j & 0xf0) << 4);
  650. j = (j & 0x0f) + LZSS_THRESHOLD;
  651. for(k = 0; k <= j; k++)
  652. {
  653. c = text_buf[(i + k) & (LZSS_N - 1)];
  654. cc = c; //add
  656. //存储这个压缩字节
  657. if(nPos >= nMaxSize)
  658. {
  659. nPos = 0;
  660. memcpy(lpUnZipData + nBufPos, byMaxBuf, nMaxSize);
  661. nBufPos += nMaxSize;
  663. ::GlobalUnlock(hUnZip); //重新分配内存
  664. hUnZip = ::GlobalReAlloc(hUnZip, nBufPos + nMaxSize, 0);
  665. lpUnZipData = (LPBYTE)::GlobalLock(hUnZip);
  666. }
  667. byMaxBuf[nPos] = cc;
  668. nPos ++;
  669. nSize ++; //当前压缩数据的大小
  671. text_buf[r++] = c; 
  672. r &= (LZSS_N - 1);
  673. }
  674. }
  675. }
  677. //存储剩余的解压数据
  678. if(nPos > 0)
  679. {
  680. memcpy(lpUnZipData + nBufPos, byMaxBuf, nPos);
  681. }
  682. ::GlobalUnlock(hUnZip); //重新分配内存
  683. hUnZip = ::GlobalReAlloc(hUnZip, nSize, 0);
  685. return hUnZip;
  686. }
  687. ///////////////////////////////////////////////////////////////////////////////
  688. //LZSS Part END--------------------------------------------------------------
  689. ///////////////////////////////////////////////////////////////////////////////
  692. ///////////////////////////////////////////////////////////////////////////////
  693. //ARI Part START--------------------------------------------------------------
  694. ///////////////////////////////////////////////////////////////////////////////
  695. HGLOBAL C_ARI::Encode(char *chData, int nSize)
  696. {
  697. if(!AfxIsValidAddress(chData, nSize))
  698. return NULL;
  700. if(nSize <= 0)
  701. return NULL;
  703. m_nTotalSize = nSize;
  705. textsize = 0;
  706. codesize = 0;
  707. printcount = 0;
  709. low = 0;
  710. high = ARI_Q4;
  711. value = 0;
  712. shifts = 0;
  714. nCurPos = 0; //记下数据的位置
  716. nZipPos = 0; //记下压缩数据的位置
  717. nBufPos = 0; //记下当前存储位置hZip
  718. nZipSize = 0; //压缩后数据的大小
  720. m_hData = NULL;
  721. m_lpMemData = NULL;
  722. m_lpBuffer = NULL;
  724. m_lpBuffer = (BYTE *)chData;
  725. m_hData = ::GlobalAlloc(GHND, MAXSIZE);
  726. if(m_hData == NULL)
  727. {
  728. return NULL;
  729. }
  730. m_lpMemData = (LPBYTE)::GlobalLock(m_hData);
  731. ZeroMemory(byMaxBuf, MAXSIZE);
  733. nCurPos = 0; //记下数据的位置
  735. nZipPos = 0; //记下压缩数据的位置
  736. nBufPos = 0; //记下当前存储位置hZip
  737. nZipSize = 0; //压缩后数据的大小
  739. int  i, c, len, r, s, last_match_length;
  741. textsize = nSize;
  742. int n1 = sizeof(textsize);
  743. memcpy(byMaxBuf, &textsize, sizeof(textsize));
  745. nZipSize += sizeof(textsize);
  746. nZipPos += sizeof(textsize);
  747. /* if(fwrite(&textsize, sizeof textsize, 1, outfile) < 1)
  748. {
  749. Error("Write Error");
  750. }
  751. */
  752. codesize += sizeof(textsize);
  753. /* if(textsize == 0)
  754. {
  755. return NULL;
  756. }
  757. */
  758. // rewind(infile);
  759. textsize = 0;
  760. StartModel(); 
  761. InitTree();
  762. s = 0;
  763. r = ARI_N - ARI_F;
  764. for(i = s; i < r; i++)
  765. {
  766. text_buf[i] = ' ';
  767. }
  768. for(len = 0; len < ARI_F && (nCurPos < nSize)/*c = getc(infile)) != EOF*/; len++)
  769. {
  770. c = m_lpBuffer[nCurPos]; //add
  771. nCurPos ++; //add
  772. text_buf[r + len] = c;
  773. }
  774. textsize = len;
  775. for(i = 1; i <= ARI_F; i++)
  776. {
  777. InsertNode(r - i);
  778. }
  779. InsertNode(r);
  780. do
  781. {
  782. if(match_length > len)
  783. {
  784. match_length = len;
  785. }
  786. if(match_length <= ARI_THRESHOLD)
  787. {
  788. match_length = 1; 
  789. EncodeChar(text_buf[r]);
  790. }
  791. else
  792. {
  793. EncodeChar(255 - ARI_THRESHOLD + match_length);
  794. EncodePosition(match_position - 1);
  795. }
  796. last_match_length = match_length;
  797. for(i = 0; i < last_match_length && (nCurPos < nSize)/*c = getc(infile)) != EOF*/; i++)
  798. {
  799. c = m_lpBuffer[nCurPos]; //add
  800. nCurPos ++; //add
  802. DeleteNode(s); 
  803. text_buf[s] = c;
  804. if(s < ARI_F - 1)
  805. {
  806. text_buf[s + ARI_N] = c;
  807. }
  808. s = (s + 1) & (ARI_N - 1);
  809. r = (r + 1) & (ARI_N - 1);
  810. InsertNode(r);
  811. }
  812. if((textsize += i) > printcount)
  813. {
  814. printcount += 1024;
  815. }
  816. while(i++ < last_match_length)
  817. {
  818. DeleteNode(s);
  819. s = (s + 1) & (ARI_N - 1);
  820. r = (r + 1) & (ARI_N - 1);
  821. if (--len) InsertNode(r);
  822. }
  823. } while (len > 0);
  824. EncodeEnd();
  825. //存储剩余的压缩数据
  826. if(nZipPos > 0)
  827. {
  828. memcpy(m_lpMemData + nBufPos, byMaxBuf, nZipPos);
  829. }
  830. ::GlobalUnlock(m_hData); //重新分配内存
  831. m_hData = ::GlobalReAlloc(m_hData, nZipSize, 0);
  832. return m_hData;
  833. }
  835. HGLOBAL C_ARI::Decode(char *chData, int nSize)
  836. {
  837. if(!AfxIsValidAddress(chData, nSize))
  838. return NULL;
  840. if(nSize <= 4)
  841. return NULL;
  843. m_nTotalSize = nSize;
  845. textsize = 0;
  846. codesize = 0;
  847. printcount = 0;
  849. low = 0;
  850. high = ARI_Q4;
  851. value = 0;
  852. shifts = 0;
  854. nCurPos = 0; //记下数据的位置
  856. nZipPos = 0; //记下压缩数据的位置
  857. nBufPos = 0; //记下当前存储位置hZip
  858. nZipSize = 0; //压缩后数据的大小
  860. m_hData = NULL;
  861. m_lpMemData = NULL;
  862. m_lpBuffer = NULL;
  864. m_lpBuffer = (BYTE *)chData;
  865. m_hData = ::GlobalAlloc(GHND, MAXSIZE);
  866. if(m_hData == NULL)
  867. {
  868. return NULL;
  869. }
  870. m_lpMemData = (LPBYTE)::GlobalLock(m_hData);
  871. ZeroMemory(byMaxBuf, MAXSIZE);
  873. nCurPos = 0; //记下数据的位置
  875. nZipPos = 0; //记下压缩数据的位置
  876. nBufPos = 0; //记下当前存储位置hZip
  877. nZipSize = 0; //压缩后数据的大小
  879. int  i, j, k, r, c;
  880. unsigned long int  count;
  882. textsize = *(unsigned long int *)(m_lpBuffer);
  883. /* if(fread(&textsize, sizeof textsize, 1, infile) < 1)
  884. {
  885. Error("Read Error");
  886. }
  887. */
  888. nCurPos += sizeof(textsize);
  890. if(textsize == 0)
  891. {
  892. return NULL;
  893. }
  894. StartDecode();
  895. StartModel();
  896. for(i = 0; i < ARI_N - ARI_F; i++)
  897. {
  898. text_buf[i] = ' ';
  899. }
  900. r = ARI_N - ARI_F;
  901. for(count = 0; count < textsize; )
  902. {
  903. c = DecodeChar();
  904. if(c < 256)
  905. {
  906. //存储这个压缩字节
  907. if(nZipPos >= MAXSIZE)
  908. {
  909. nZipPos = 0;
  910. memcpy(m_lpMemData + nBufPos, byMaxBuf, MAXSIZE);
  911. nBufPos += MAXSIZE;
  913. ::GlobalUnlock(m_hData); //重新分配内存
  914. m_hData = ::GlobalReAlloc(m_hData, nBufPos + MAXSIZE, 0);
  915. m_lpMemData = (LPBYTE)::GlobalLock(m_hData);
  916. }
  917. byMaxBuf[nZipPos] = c;
  918. nZipPos ++;
  919. nZipSize ++; //当前压缩数据的大小
  921. text_buf[r++] = c;
  922. r &= (ARI_N - 1);
  923. count++;
  924. } 
  925. else
  926. {
  927. i = (r - DecodePosition() - 1) & (ARI_N - 1);
  928. j = c - 255 + ARI_THRESHOLD;
  929. for(k = 0; k < j; k++)
  930. {
  931. c = text_buf[(i + k) & (ARI_N - 1)];
  932. //存储这个压缩字节
  933. if(nZipPos >= MAXSIZE)
  934. {
  935. nZipPos = 0;
  936. memcpy(m_lpMemData + nBufPos, byMaxBuf, MAXSIZE);
  937. nBufPos += MAXSIZE;
  939. ::GlobalUnlock(m_hData); //重新分配内存
  940. m_hData = ::GlobalReAlloc(m_hData, nBufPos + MAXSIZE, 0);
  941. m_lpMemData = (LPBYTE)::GlobalLock(m_hData);
  942. }
  943. byMaxBuf[nZipPos] = c;
  944. nZipPos ++;
  945. nZipSize ++; //当前压缩数据的大小
  947. text_buf[r++] = c;
  948. r &= (ARI_N - 1);
  949. count++;
  950. }
  951. }
  952. }
  954. //存储剩余的压缩数据
  955. if(nZipPos > 0)
  956. {
  957. memcpy(m_lpMemData + nBufPos, byMaxBuf, nZipPos);
  958. }
  959. ::GlobalUnlock(m_hData); //重新分配内存
  960. m_hData = ::GlobalReAlloc(m_hData, nZipSize, 0);
  961. return m_hData;
  962. }
  964. ///////////////////////////////////////////////////////////////////////////////
  965. //ARI Part END--------------------------------------------------------------
  966. ///////////////////////////////////////////////////////////////////////////////
  969. ///////////////////////////////////////////////////////////////////////////////
  970. //LZW Part START--------------------------------------------------------------
  971. ///////////////////////////////////////////////////////////////////////////////
  973. CLZWDecodeTable::CLZWDecodeTable(BOOL fInit)
  974. {
  975. m_pbContain=NULL;
  976. m_dwTableEntryNumber=0;
  977. if(fInit)
  978. InitLZWTable();
  979. }
  980. CLZWDecodeTable::~CLZWDecodeTable()
  981. {
  982. ClearDecodeTable();
  983. }
  984. void CLZWDecodeTable::ClearDecodeTable(void)
  985. {   
  986. if(m_pbContain==NULL)
  987. return;
  988. for(int i=0;i<4096;i++)
  989. {
  990. if(m_pbContain[i])
  991. delete (m_pbContain[i]);
  992. }
  993. delete m_pbContain;
  994. m_pbContain=NULL;
  995. m_dwTableEntryNumber=0;
  996. }
  997. void CLZWDecodeTable::InitLZWTable(void)
  998. {
  999. ClearDecodeTable();
  1000. m_pbContain=new BYTE*[4096];
  1001. int iSize=sizeof(m_pbContain);
  1002. //if(NULL==m_pbContain)
  1003. // AfxMessageBox("error new m_pbContain=BYTE*[4096]");
  1004. for(int i=0;i<4096;i++)
  1005. {
  1006. m_pbContain[i]=NULL;
  1007. }
  1008. for(i=0;i<=255;i++)
  1009. {
  1010. m_pbContain[i]=new BYTE[1+2];
  1011. *((WORD*)m_pbContain[i])=1;
  1012. m_pbContain[i][2]=(BYTE)i;
  1013. }
  1014. m_dwTableEntryNumber=LZW_BEGIN_ENTRY;
  1015. }
  1016. BYTE* CLZWDecodeTable::GetMatchData(WORD wCode)
  1017. {
  1018. return m_pbContain[wCode];
  1019. }
  1020. void CLZWDecodeTable::AddToChild(WORD wCode,BYTE *pbContain,int iLength)
  1021. {
  1022. ASSERT(wCode<4096);
  1023. if(m_pbContain[wCode])
  1024. delete m_pbContain[wCode];
  1025. m_pbContain[wCode]=new BYTE[iLength+2];
  1026. *((WORD*)m_pbContain[wCode])=(WORD)iLength;
  1027. memcpy(m_pbContain[wCode]+2,pbContain,iLength);
  1028. }
  1030. /*
  1031. class CLZWEncodeTable
  1032. */
  1033. CLZWEncodeTable::CLZWEncodeTable(BOOL fInit)
  1034. {
  1035. if(fInit)
  1036. InitLZWTable();
  1037. else
  1038. {
  1039. m_dwTableEntryNumber=0;
  1040. m_EntryHead.pRightBrother=NULL;
  1041. m_EntryHead.pChild=NULL;
  1042. }
  1043. }
  1044. CLZWEncodeTable::~CLZWEncodeTable()
  1045. {
  1046. ClearLZWTable();
  1047. }
  1048. void CLZWEncodeTable::ClearLZWTable(void)
  1049. {
  1050. if(m_EntryHead.pChild==NULL)
  1051. return;
  1052. m_dwTableEntryNumber=0;
  1053. int iRe=0;
  1054. while(m_EntryHead.pChild)
  1055. {
  1056. RemoveFirstChild();
  1057. iRe++;
  1058. //printf("remove %dn",++iRe);;
  1059. }
  1060. }
  1061. void CLZWEncodeTable::RemoveFirstChild(void)
  1062. {
  1063. PLZWENCODEENTRY pFirstChild=m_EntryHead.pChild;// this child will be removed
  1064. if(pFirstChild->pChild)
  1065. {
  1066. m_EntryHead.pChild=pFirstChild->pChild;
  1067. if(m_EntryHead.pChild->pRightBrother)
  1068. {
  1069. PLZWENCODEENTRY pRightBrother=FindRightBrother(m_EntryHead.pChild);
  1070. pRightBrother->pRightBrother=pFirstChild->pRightBrother;
  1071. }
  1072. else
  1073. (m_EntryHead.pChild)->pRightBrother=pFirstChild->pRightBrother;
  1074. //delete pFirstChild;
  1075. }
  1076. else
  1077. m_EntryHead.pChild=pFirstChild->pRightBrother;
  1078. delete pFirstChild;
  1079. }
  1080. PLZWENCODEENTRY CLZWEncodeTable::FindRightBrother(PLZWENCODEENTRY pCurrent)
  1081. {
  1082. PLZWENCODEENTRY pFind;
  1083. pFind=pCurrent;
  1084. while(pFind->pRightBrother)
  1085. {
  1086. pFind=pFind->pRightBrother;
  1087. }
  1088. return pFind;
  1089. }
  1090. void CLZWEncodeTable::InitLZWTable(void)
  1091. {// init the table ,it has 256 items code from 0 to 255
  1092. ClearLZWTable();
  1093. PLZWENCODEENTRY pEntryFirst=new LZWENCODEENTRY;
  1094. pEntryFirst->wCode=(WORD)0;
  1095. pEntryFirst->bLast=(BYTE)0;
  1096. pEntryFirst->pRightBrother=pEntryFirst->pChild=NULL;
  1097. m_EntryHead.pChild=pEntryFirst;
  1098. m_EntryHead.pRightBrother=NULL;
  1099. PLZWENCODEENTRY pPrev=pEntryFirst;
  1100. for(int i=1;i<=255;i++)
  1101. {// set the brother nodes
  1102. PLZWENCODEENTRY pEntry=new LZWENCODEENTRY;
  1103. pEntry->wCode=(WORD)i;
  1104. pEntry->bLast=(BYTE)i;
  1105. pEntry->pChild=pEntry->pRightBrother=NULL;
  1106. pPrev->pRightBrother=pEntry;
  1107. pPrev=pEntry;
  1108. }
  1109. m_dwTableEntryNumber=258;
  1110. m_uNextCodeForUse=LZW_BEGIN_ENTRY;
  1111. }
  1112. PLZWENCODEENTRY CLZWEncodeTable::FindMatchChild(BYTE bChildLast,PLZWENCODEENTRY pCurrent)
  1113. {// return the find child entry
  1114. if(pCurrent->pChild==NULL)
  1115. return NULL;
  1116. PLZWENCODEENTRY pChild=pCurrent->pChild;
  1117. // pChild is the current's child
  1118. // and all pChild's brother is the current's child
  1119. while(pChild!=NULL)
  1120. {
  1121. if(pChild->bLast==bChildLast)
  1122. return pChild;
  1123. pChild=pChild->pRightBrother;
  1124. }
  1125. return NULL;
  1126. }
  1127. PLZWENCODEENTRY CLZWEncodeTable::AddToChild(BYTE bLast,PLZWENCODEENTRY pCurrent)
  1128. {
  1129. ASSERT(pCurrent);
  1130. PLZWENCODEENTRY pChild=new LZWENCODEENTRY;
  1131. if(pChild==NULL)
  1132. {
  1133. int _j=0;
  1134. }
  1135. pChild->pChild=pChild->pRightBrother=NULL;
  1136. pChild->bLast=bLast;
  1137. pChild->wCode=(WORD)m_uNextCodeForUse;
  1138. if(pChild->wCode==LZW_CLEAR_CODE)
  1139. {
  1140. int _i=0;
  1141. }
  1142. m_uNextCodeForUse++;
  1143. m_dwTableEntryNumber++;
  1144. pChild->pRightBrother=pCurrent->pChild;
  1145. pCurrent->pChild=pChild;
  1146. return pChild;
  1147. }
  1149. CDecodeBitArray::CDecodeBitArray(DWORD dwInitWidth)// width in bit
  1150. {
  1151. m_pbBits=NULL;
  1152. m_dwWidthInByte=0;
  1153. m_dwTail=m_dwHead=0;
  1154. if(dwInitWidth)
  1155. InitBits(dwInitWidth);
  1156. }
  1157. CDecodeBitArray::~CDecodeBitArray()
  1158. {
  1159. ClearBits();
  1160. }
  1161. void CDecodeBitArray::ClearBits(void)
  1162. {
  1163. if(m_pbBits)
  1164. delete m_pbBits;
  1165. m_dwTail=m_dwHead=0;
  1166. m_dwWidthInByte=0;
  1167. }
  1168. void CDecodeBitArray::InitBits(DWORD dwInitWidth)
  1169. {
  1170. ClearBits();
  1171. DWORD dwLength=dwInitWidth/8;
  1172. dwLength+=(dwInitWidth%8)?1:0;
  1173. m_pbBits=new BYTE[dwLength];
  1174. m_dwHead=m_dwTail=0;
  1175. m_dwWidthInByte=dwLength;
  1176. }
  1177. void CDecodeBitArray::InitBytes(DWORD dwInitWidth)
  1178. {
  1179. InitBits(dwInitWidth*8);
  1180. }
  1181. DWORD CDecodeBitArray::GetLeftBytes(void)
  1182. {
  1183. DWORD dwLeftBytes;
  1184. DWORD dwLeftBits=GetLeftBits();
  1185. dwLeftBytes=dwLeftBits/8;
  1186. dwLeftBytes+=(dwLeftBits%8)?1:0;
  1187. return dwLeftBytes;
  1188. }
  1189. WORD CDecodeBitArray::RemoveBits(int iWidth)
  1190. {
  1191. WORD wGet=0;
  1192. for(int i=iWidth-1;i>=0;i--)
  1193. {
  1194. if(RemoveFirstBit())
  1195. {
  1196. (wGet |= (1<<i));
  1197. }
  1198. //// SET_BIT_1(wGet,i);
  1199. }
  1200. return wGet;
  1201. }
  1202. WORD CDecodeBitArray::RemoveFirstBit(void)
  1203. {
  1204. BYTE* pbFirstByte=m_pbBits+m_dwHead/8;
  1205. BYTE bFirstByte=*pbFirstByte;
  1206. //  (b & (1<<i))
  1207. WORD wGet= bFirstByte&(1<<(7-m_dwHead%8))?1:0;
  1208. m_dwHead++;
  1209. return wGet;
  1210. }
  1211. BOOL CDecodeBitArray::AddBytes(BYTE* pbAdd,int iLength)
  1212. {
  1213. if(m_pbBits==NULL)
  1214. return FALSE;
  1215. Resort();
  1216. memcpy(m_pbBits+m_dwTail/8,pbAdd,iLength);
  1217. m_dwTail+=8*(DWORD)iLength;
  1218. return TRUE;
  1219. }
  1220. void CDecodeBitArray::Resort(void)
  1221. {// because m_dwTail%8 always equal 0
  1222. if(m_dwHead<8)
  1223. return;
  1224. if(m_dwTail==m_dwHead)
  1225. {
  1226. m_dwTail=m_dwHead=0;
  1227. return;
  1228. }
  1229. DWORD dwLength=GetLeftBytes();
  1230. DWORD dwHead=m_dwHead%8;
  1231. DWORD dwMove=m_dwHead-dwHead;
  1232. memcpy(m_pbBits,m_pbBits+(m_dwHead/8),(int)dwLength);
  1233. m_dwHead=dwHead;
  1234. m_dwTail-=dwMove;
  1235. }
  1237. /*
  1238. class CEncodeBitArray
  1239. */
  1240. CEncodeBitArray::CEncodeBitArray(DWORD dwInitWidth)
  1241. {
  1242. if(dwInitWidth==0)
  1243. m_pbBits=NULL;
  1244. else
  1245. InitBits(dwInitWidth);
  1246. }
  1247. CEncodeBitArray::~CEncodeBitArray()
  1248. {
  1249. ClearBits();
  1250. }
  1251. BOOL CEncodeBitArray::InitBits(DWORD dwInitWidth)
  1252. {
  1253. ClearBits();
  1254. ASSERT(dwInitWidth);
  1255. m_dwWidthInByte=dwInitWidth/8;
  1256. m_dwWidthInByte+=(dwInitWidth%8)?1:0;
  1257. m_pbBits=new BYTE[m_dwWidthInByte];
  1258. m_dwTail=0;
  1259. return TRUE;
  1260. }
  1261. void CEncodeBitArray::ClearBits(void)
  1262. {
  1263. if(m_pbBits)
  1264. delete m_pbBits;
  1265. m_pbBits=NULL;
  1266. }
  1267. BOOL CEncodeBitArray::AddBits(WORD wAdd,int iWidth)
  1268. {
  1269. if(m_pbBits==NULL)
  1270. return FALSE;
  1271. for(int i=iWidth-1;i>=0;i--)
  1272. {
  1273. BYTE* pbByte=m_pbBits+m_dwTail/8;
  1274. if((wAdd & (1<<i)))//  CHECK_BIT_1(wAdd,i))
  1275. ((*pbByte) |= (1<<(7-m_dwTail%8)));//SET_BIT_1(*pbByte,7-m_dwTail%8);
  1276. else
  1277. ((*pbByte) &= (~(1<<(7-m_dwTail%8))));//SET_BIT_0(*pbByte,7-m_dwTail%8);
  1278. m_dwTail++;
  1279. }
  1280. return TRUE;
  1281. }
  1282. DWORD CEncodeBitArray::GetBytesWidth(void)
  1283. {
  1284. DWORD dwBytes=m_dwTail/8;
  1285. dwBytes+=(m_dwTail%8)?1:0;
  1286. return dwBytes;
  1287. }
  1288. int CEncodeBitArray::RemoveBytes(BYTE *pbGet,int iWant)
  1289. {
  1290. if(m_pbBits==NULL)
  1291. return -1;
  1292. int iTotal=(int)GetBytesWidth();
  1293. if(iWant>iTotal)
  1294. iWant=iTotal;
  1295. if(pbGet!=NULL)
  1296. memcpy(pbGet,m_pbBits,iWant);
  1297. memcpy(m_pbBits,m_pbBits+iWant,iTotal-iWant);
  1298. int iTail=(int)m_dwTail;
  1299. iTail-=iWant*8;
  1300. if(iTail<0)
  1301. iTail=0;
  1302. m_dwTail=iTail;
  1303. return iWant;
  1304. }
  1306. HGLOBAL CLZWDecode::BeginLZWDecode(char *chZipData, int dwLength)
  1307. {
  1308. if(!AfxIsValidAddress(chZipData, dwLength))
  1309. return NULL;
  1312. //缓冲数据区大小
  1313. const int nMaxSize = 65536;
  1314. HGLOBAL hUnZip = NULL;
  1315. hUnZip = ::GlobalAlloc(GHND, nMaxSize);
  1316. if(hUnZip == NULL)
  1317. {
  1318. return NULL;
  1319. }
  1320. LPBYTE lpZipData = (LPBYTE)::GlobalLock(hUnZip);
  1321. BYTE byMaxBuf[nMaxSize];
  1322. ZeroMemory(byMaxBuf, nMaxSize);
  1323. int nZipPos = 0; //记下压缩数据的位置
  1324. int nBufPos = 0; //记下当前存储位置hZip
  1325. int nZipSize = 0; //压缩后数据的大小
  1327. iDePutPos=iDeGetPos=0;
  1329. DWORD dwBytesOnce = 1;
  1330. DWORD wBuffer = 1024;
  1331. m_dwDecodedByte=0;
  1332. BYTE *pbNewData=new BYTE[4000],*pbOutData=new BYTE[4000];
  1333. BYTE *pbBuffer=new BYTE[wBuffer];
  1334. BYTE bFirst;
  1335. m_LZWTable.InitLZWTable();
  1336. int iBitWidth=9;
  1337. m_iTotalEntry=LZW_BEGIN_ENTRY;
  1338. BYTE* pbDecodedData;
  1339. WORD wOld,wLastLen;
  1340. m_baContain.InitBits((wBuffer+20)*8);
  1341. int iR=0;
  1342. DWORD dwRead=0;
  1343. while(1)
  1344. {
  1345. if(m_baContain.GetLeftBytes()<5)
  1346. {
  1347. WORD wGetBytes= (WORD)wBuffer;
  1348. if((DWORD)wGetBytes+dwRead>(DWORD)dwLength)
  1349. wGetBytes=(WORD)(dwLength-dwRead);
  1350. if(wGetBytes!=0)
  1351. {
  1352. ///////////////////////////////////
  1353. int iGet = wGetBytes;
  1354. if(iDeGetPos + iGet > dwLength)
  1355. iGet = dwLength - iDeGetPos;
  1356. memcpy(pbBuffer, chZipData + iDeGetPos, iGet);
  1357. iDeGetPos += iGet;
  1358. ///////////////////////////////////
  1359. m_baContain.AddBytes(pbBuffer,wBuffer);
  1360. dwRead+=wGetBytes;
  1361. }
  1362. }
  1363. int iT=m_iTotalEntry+1;
  1364. iT>>=9;
  1365. iBitWidth=9;
  1366. while(iT>0)
  1367. {
  1368. iT>>=1;
  1369. iBitWidth++;
  1370. }
  1371. WORD wGet=m_baContain.RemoveBits(iBitWidth);
  1372. if(wGet==LZW_END_CODE)
  1373. {
  1374. break;
  1375. }
  1376. if(wGet==LZW_CLEAR_CODE)
  1377. {
  1378. m_LZWTable.InitLZWTable();
  1379. wGet=m_baContain.RemoveBits(9);
  1380. if(wGet==LZW_END_CODE)
  1381. break;
  1382. pbDecodedData=m_LZWTable.GetMatchData(wGet);
  1384. //////////////////////////////
  1385. BYTE *pbWrite = pbDecodedData;
  1386. if(pbWrite != NULL)
  1387. {
  1388. WORD wL=*((WORD*)pbWrite);
  1389. pbWrite+=sizeof(WORD);
  1390. for(DWORD i=0;i<wL;i++)
  1391. {
  1392. //存储这个压缩
  1393. if(nZipPos >= nMaxSize)
  1394. {
  1395. memcpy(lpZipData + nBufPos, byMaxBuf, nMaxSize);
  1396. nBufPos += nMaxSize;
  1397. nZipPos = 0;
  1398. ::GlobalUnlock(hUnZip); //重新分配内存
  1399. hUnZip = ::GlobalReAlloc(hUnZip, nBufPos + nMaxSize, 0);
  1400. lpZipData = (LPBYTE)::GlobalLock(hUnZip);
  1401. }
  1402. byMaxBuf[nZipPos] = *pbWrite;
  1403. nZipPos ++;//
  1404. nZipSize ++; //add
  1407. pbWrite++;
  1408. }
  1409. m_dwDecodedByte+=wL;
  1410. }
  1412. //////////////////////////////
  1413. wOld=wGet;
  1414. m_iTotalEntry=258;
  1415. }
  1416. else
  1417. {// not clear
  1418. pbDecodedData=m_LZWTable.GetMatchData(wGet);
  1419. if(NULL!=pbDecodedData)
  1420. {// in table
  1421. bFirst=pbDecodedData[2];
  1422. //////////////////////////////
  1423. BYTE *pbWrite = pbDecodedData;
  1424. if(pbWrite != NULL)
  1425. {
  1426. WORD wL=*((WORD*)pbWrite);
  1427. pbWrite+=sizeof(WORD);
  1428. for(DWORD i=0;i<wL;i++)
  1429. {
  1430. //存储这个压缩
  1431. if(nZipPos >= nMaxSize)
  1432. {
  1433. memcpy(lpZipData + nBufPos, byMaxBuf, nMaxSize);
  1434. nBufPos += nMaxSize;
  1435. nZipPos = 0;
  1436. ::GlobalUnlock(hUnZip); //重新分配内存
  1437. hUnZip = ::GlobalReAlloc(hUnZip, nBufPos + nMaxSize, 0);
  1438. lpZipData = (LPBYTE)::GlobalLock(hUnZip);
  1439. }
  1440. byMaxBuf[nZipPos] = *pbWrite;
  1441. nZipPos ++;//
  1442. nZipSize ++; //add
  1445. pbWrite++;
  1446. }
  1447. m_dwDecodedByte+=wL;
  1448. }
  1450. //////////////////////////////
  1451. if(wOld!=LZW_CLEAR_CODE)
  1452. {// not the first code be read in
  1453. pbDecodedData=m_LZWTable.GetMatchData(wOld);
  1454. wLastLen=*((WORD*)pbDecodedData);
  1455. memcpy(pbNewData,pbDecodedData+2,wLastLen);
  1456. pbNewData[wLastLen]=bFirst;
  1457. m_LZWTable.AddToChild((WORD)m_iTotalEntry,pbNewData,wLastLen+1);
  1458. m_iTotalEntry+=1;
  1459. }
  1460. wOld=wGet;
  1461. }
  1462. else
  1463. {
  1464. pbDecodedData=m_LZWTable.GetMatchData(wOld);
  1465. bFirst=pbDecodedData[2];
  1466. wLastLen=*((WORD*)pbDecodedData);
  1467. memcpy(pbOutData+2,pbDecodedData+2,wLastLen);
  1468. pbOutData[wLastLen+2]=bFirst;
  1469. *((WORD*)pbOutData)=wLastLen+1;
  1470. //////////////////////////////
  1471. BYTE *pbWrite = pbOutData;
  1472. if(pbWrite != NULL)
  1473. {
  1474. WORD wL=*((WORD*)pbWrite);
  1475. pbWrite+=sizeof(WORD);
  1476. for(DWORD i=0;i<wL;i++)
  1477. {
  1478. //存储这个压缩
  1479. if(nZipPos >= nMaxSize)
  1480. {
  1481. memcpy(lpZipData + nBufPos, byMaxBuf, nMaxSize);
  1482. nBufPos += nMaxSize;
  1483. nZipPos = 0;
  1484. ::GlobalUnlock(hUnZip); //重新分配内存
  1485. hUnZip = ::GlobalReAlloc(hUnZip, nBufPos + nMaxSize, 0);
  1486. lpZipData = (LPBYTE)::GlobalLock(hUnZip);
  1487. }
  1488. byMaxBuf[nZipPos] = *pbWrite;
  1489. nZipPos ++;//
  1490. nZipSize ++; //add
  1493. pbWrite++;
  1494. }
  1495. m_dwDecodedByte+=wL;
  1496. }
  1498. //////////////////////////////
  1499. if(m_iTotalEntry>=4096)
  1500. {
  1501. int _j=0;
  1502. }
  1503. m_LZWTable.AddToChild((WORD)m_iTotalEntry,pbOutData+2,wLastLen+1);
  1504. m_iTotalEntry+=1;
  1505. wOld=wGet;
  1506. }
  1507. }
  1508. }
  1509. delete pbNewData;
  1510. delete pbOutData;
  1511. delete pbBuffer;
  1513. if(dwRead != (DWORD)dwLength)
  1514. {
  1515. GlobalFree(hUnZip);
  1516. hUnZip = NULL;
  1517. }
  1519. //存储剩余的压缩数据
  1520. if(nZipPos > 0)
  1521. {
  1522. memcpy(lpZipData + nBufPos, byMaxBuf, nZipPos);
  1523. }
  1524. ::GlobalUnlock(hUnZip); //重新分配内存
  1525. hUnZip = ::GlobalReAlloc(hUnZip, nZipSize, 0);
  1527. return hUnZip;
  1528. }
  1530. /*
  1531. CLZWEncode
  1532. */
  1533. HGLOBAL CLZWEncode::BeginLZWEncode(char *chData, int dwLength)
  1534. {
  1535. if(!AfxIsValidAddress(chData, dwLength))
  1536. return NULL;
  1538. //缓冲数据区大小
  1539. const int nMaxSize = 65536;
  1540. HGLOBAL hZip = NULL;
  1541. hZip = ::GlobalAlloc(GHND, nMaxSize);
  1542. if(hZip == NULL)
  1543. {
  1544. return NULL;
  1545. }
  1546. LPBYTE lpZipData = (LPBYTE)::GlobalLock(hZip);
  1547. BYTE byMaxBuf[nMaxSize];
  1548. ZeroMemory(byMaxBuf, nMaxSize);
  1549. int nZipPos = 0; //记下压缩数据的位置
  1550. int nBufPos = 0; //记下当前存储位置hZip
  1551. int nZipSize = 0; //压缩后数据的大小
  1554. m_dwCompressedLength = 0;
  1555. WORD wBufferLen = 1024;
  1556. int iBufferLen = wBufferLen = 1024;
  1557. BYTE bGet;
  1558. int nCurPos = 0;
  1559. m_LZWTable.InitLZWTable();// init the entry table
  1560. m_baContain.InitBits((iBufferLen+8)*8);// init the bit array
  1561. m_baContain.AddBits(LZW_CLEAR_CODE,9);// add the first clear code
  1562. /// below : begin the algorithm
  1563. PLZWENCODEENTRY pCurrent = m_LZWTable.GetHead();
  1564. int iBitWidth;
  1565. DWORD dwEncoded=0;
  1566. for(DWORD i = 0; i < (DWORD)dwLength; i ++)
  1567. {// for each byte
  1568. bGet = chData[nCurPos]; // add
  1569. nCurPos ++;
  1571. PLZWENCODEENTRY pChild=m_LZWTable.FindMatchChild(bGet,pCurrent);
  1572. if(pChild)
  1573. {// has found the continue
  1574. pCurrent=pChild;
  1575. }
  1576. else
  1577. {// not find write last code & add new entry 
  1578. iBitWidth=GetBitWidth();
  1579. WORD wW=pCurrent->wCode;
  1580. m_baContain.AddBits(wW,iBitWidth);// add last code to buffer
  1581. m_LZWTable.AddToChild(bGet,pCurrent);// add last code to table
  1582. if(m_baContain.GetBytesWidth()>(DWORD)iBufferLen)
  1583. {
  1584. m_dwCompressedLength+=(DWORD)iBufferLen;
  1586. //存储这个压缩
  1587. if(nZipPos + iBufferLen >= nMaxSize)
  1588. {
  1589. memcpy(lpZipData + nBufPos, byMaxBuf, nZipPos);
  1590. nBufPos += nZipPos;
  1591. nZipPos = 0;
  1592. ::GlobalUnlock(hZip); //重新分配内存
  1593. hZip = ::GlobalReAlloc(hZip, nBufPos + nMaxSize, 0);
  1594. lpZipData = (LPBYTE)::GlobalLock(hZip);
  1595. }
  1597. memcpy(byMaxBuf + nZipPos, m_baContain.GetBits(), iBufferLen);
  1598. nZipPos += iBufferLen;
  1599. nZipSize += iBufferLen; //add
  1601. m_baContain.RemoveBytes(NULL,iBufferLen);
  1602. }
  1603. if(m_LZWTable.GetTableEntryNumber()>= (DWORD)(m_wMaxEntry-3))
  1604. {
  1605. iBitWidth=GetBitWidth();
  1606. m_baContain.AddBits(LZW_CLEAR_CODE,iBitWidth);
  1607. m_LZWTable.InitLZWTable();
  1608. }
  1609. pCurrent=m_LZWTable.FindMatchChild(bGet,m_LZWTable.GetHead());
  1610. }
  1611. dwEncoded++;
  1612. }
  1613. iBitWidth=GetBitWidth();
  1614. m_baContain.AddBits(pCurrent->wCode,iBitWidth);// add last code to buffer
  1617. iBitWidth=GetBitWidth();
  1618. m_baContain.AddBits(LZW_END_CODE,iBitWidth);
  1619. m_dwCompressedLength+=m_baContain.GetBytesWidth();
  1620. iBufferLen = m_baContain.GetBytesWidth();
  1621. //存储这个压缩
  1622. if(nZipPos + iBufferLen >= nMaxSize)
  1623. {
  1624. memcpy(lpZipData + nBufPos, byMaxBuf, nZipPos);
  1625. nBufPos += nZipPos;
  1626. nZipPos = 0;
  1627. ::GlobalUnlock(hZip); //重新分配内存
  1628. hZip = ::GlobalReAlloc(hZip, nBufPos + nMaxSize, 0);
  1629. lpZipData = (LPBYTE)::GlobalLock(hZip);
  1630. }
  1632. memcpy(byMaxBuf + nZipPos, m_baContain.GetBits(), iBufferLen);
  1633. nZipPos += iBufferLen;
  1634. nZipSize += iBufferLen; //add
  1637. m_LZWTable.ClearLZWTable();
  1638. m_baContain.ClearBits();
  1640. //存储剩余的压缩数据
  1641. if(nZipPos > 0)
  1642. {
  1643. memcpy(lpZipData + nBufPos, byMaxBuf, nZipPos);
  1644. }
  1645. ::GlobalUnlock(hZip); //重新分配内存
  1646. hZip = ::GlobalReAlloc(hZip, nZipSize, 0);
  1649. return hZip;
  1650. }
  1652. int CLZWEncode::GetBitWidth(void)
  1653. {
  1654. int iTotal=(int)m_LZWTable.GetTableEntryNumber();
  1655. iTotal>>=9;
  1656. int iBitWidth=9;
  1657. while(iTotal>0)
  1658. {
  1659. iTotal>>=1;
  1660. iBitWidth+=1;
  1661. }
  1662. return iBitWidth;
  1663. }
  1665. HGLOBAL C_LZW::Encode(char *chData, int nSize)
  1666. {
  1667. CLZWEncode cl;
  1668. return cl.BeginLZWEncode(chData, nSize);
  1669. }
  1671. HGLOBAL C_LZW::Decode(char *chZipData, int nZipSize)
  1672. {
  1673. CLZWDecode cl;
  1674. return cl.BeginLZWDecode(chZipData, nZipSize);
  1675. }
  1677. ///////////////////////////////////////////////////////////////////////////////
  1678. //LZW Part END--------------------------------------------------------------
  1679. ///////////////////////////////////////////////////////////////////////////////