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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 查看源码
GIFAPI.CPP
资源名称：VisualC++.rar　[点击查看]
上传用户：gdjinyi
上传日期：2013-02-01
资源大小：1701k
文件大小：36k
源码类别：

源码/资料

开发平台：

Visual C++

GIFAPI.CPP：源码内容
  1. // ************************************************************************
  2. //  文件名：GIFAPI.cpp
  3. //
  4. //  GIF(Graphics Interchange Format) API函数库：
  5. //
  6. //  DIBToGIF()          - 将指定的DIB对象（< 256色）保存为GIF文件
  7. //  EncodeGIF_LZW() - 对指定图像进行GIF_LZW编码
  8. //  GIF_LZW_WriteCode() - 输出一个编码
  9. //  ReadGIF()           - 读取GIF文件
  10. //  DecodeGIF_LZW()     - 对GIF_LZW编码结果进行解码
  11. //  ReadSrcData()       - 读取GIF_LZW编码
  12. //
  13. // ************************************************************************
  15. #include "stdafx.h"
  16. #include "DIBAPI.h"
  17. #include "GIFAPI.h"
  19. #include <io.h>
  20. #include <errno.h>
  22. #include <math.h>
  23. #include <direct.h>
  25. /*************************************************************************
  26.  *
  27.  * 函数名称：
  28.  *   DIBToGIF()
  29.  *
  30.  * 参数:
  31.  *   LPSTR lpDIB        - 指向DIB对象的指针
  32.  *   CFile& file        - 要保存的文件
  33.  *   BOOL bInterlace - 是否按照交错方式保存
  34.  *
  35.  * 返回值:
  36.  *   BOOL               - 成功返回True，否则返回False。
  37.  *
  38.  * 说明:
  39.  *   该函数将指定的DIB对象（< 256色）保存为GIF文件。
  40.  *
  41.  *************************************************************************/
  42. BOOL WINAPI DIBToGIF(LPSTR lpDIB, CFile& file, BOOL bInterlace)
  43. {
  44. // 循环变量
  45. WORD i;
  46. WORD j;
  48. // DIB高度
  49. WORD wHeight;
  51. // DIB宽度
  52. WORD wWidth;
  54. // 指向DIB象素指针
  55. LPSTR   lpDIBBits;
  57. // GIF文件头
  58. GIFHEADER          GIFH;
  60. // GIF逻辑屏幕描述块
  61. GIFSCRDESC         GIFS;
  63. // GIF图像描述块
  64. GIFIMAGE           GIFI;
  66. // GIF编码参数
  67. GIFC_VAR           GIFCVar;
  69. // 颜色数目
  70. WORD               wColors;
  72. // 每行字节数
  73. WORD               wWidthBytes;
  75. // 调色板
  76. BYTE               byGIF_Pal[768];
  78. // 字节变量
  79. BYTE               byChar;
  81. // 指向BITMAPINFO结构的指针（Win3.0）
  82. LPBITMAPINFO    lpbmi;
  84. // 指向BITMAPCOREINFO结构的指针
  85. LPBITMAPCOREINFO   lpbmc;
  87. // 表明是否是Win3.0 DIB的标记
  88. BOOL    bWinStyleDIB;
  90. // 获取DIB高度
  91. wHeight = (WORD) DIBHeight(lpDIB);
  93. // 获取DIB宽度
  94. wWidth  = (WORD) DIBWidth(lpDIB);
  96. // 找到DIB图像象素起始位置
  97. lpDIBBits = FindDIBBits(lpDIB);
  99. // 给GIFCVar结构赋值
  100. GIFCVar.wWidth     = wWidth;
  101. GIFCVar.wDepth     = wHeight;
  102. GIFCVar.wBits      = DIBBitCount(lpDIB);
  103. GIFCVar.wLineBytes = (WORD)BYTE_WBYTES((DWORD)GIFCVar.wWidth *
  104.    (DWORD)GIFCVar.wBits);
  106. // 计算每行字节数
  107. wWidthBytes = (WORD)DWORD_WBYTES(wWidth * (DWORD)GIFCVar.wBits);
  109. // 计算颜色数目
  110. wColors     = 1 << GIFCVar.wBits;
  112. // 获取指向BITMAPINFO结构的指针（Win3.0）
  113. lpbmi = (LPBITMAPINFO)lpDIB;
  115. // 获取指向BITMAPCOREINFO结构的指针
  116. lpbmc = (LPBITMAPCOREINFO)lpDIB;
  118. // 判断是否是WIN3.0的DIB
  119. bWinStyleDIB = IS_WIN30_DIB(lpDIB);
  121. // 给调色板赋值
  122. if (bWinStyleDIB)
  123. {
  124. j = 0;
  125. for (i = 0; i < wColors; i++)
  126. {
  127. // 读取红色分量
  128. byGIF_Pal[j++] = lpbmi->bmiColors[i].rgbRed;
  130. // 读取绿色分量
  131. byGIF_Pal[j++] = lpbmi->bmiColors[i].rgbGreen;
  133. // 读取蓝色分量
  134. byGIF_Pal[j++] = lpbmi->bmiColors[i].rgbBlue;
  135. }
  136. }
  137. else
  138. {
  139. j = 0;
  140. for (i = 0; i < wColors; i++)
  141. {
  142. // 读取红色分量
  143. byGIF_Pal[j++] = lpbmc->bmciColors[i].rgbtRed;
  145. // 读取绿色分量
  146. byGIF_Pal[j++] = lpbmc->bmciColors[i].rgbtGreen;
  148. // 读取红色分量
  149. byGIF_Pal[j++] = lpbmc->bmciColors[i].rgbtBlue;
  150. }
  151. }
  153. ////////////////////////////////////////////////////////////////////////////////////////
  154. // 开始写GIF文件
  156. // 写GIF文件头
  157. GIFH.bySignature[0] = 'G';
  158. GIFH.bySignature[1] = 'I';
  159. GIFH.bySignature[2] = 'F';
  160. GIFH.byVersion[0]='8';
  161. GIFH.byVersion[1]='9';
  162. GIFH.byVersion[2]='a';
  163. file.Write((LPSTR)&GIFH, 6);
  165. // 写GIF逻辑屏幕描述块
  166. GIFS.wWidth               = GIFCVar.wWidth;
  167. GIFS.wDepth               = GIFCVar.wDepth;
  168. GIFS.GlobalFlag.PalBits   = (BYTE)(GIFCVar.wBits - 1);
  169. GIFS.GlobalFlag.SortFlag  = 0x00;
  170. GIFS.GlobalFlag.ColorRes  = (BYTE)(GIFCVar.wBits - 1);
  171. GIFS.GlobalFlag.GlobalPal = 0x01;
  172. GIFS.byBackground         = 0x00;
  173. GIFS.byAspect             = 0x00;
  174. file.Write((LPSTR)&GIFS, 7);
  176. // 写GIF全局调色板
  177. file.Write((LPSTR)byGIF_Pal,(wColors*3));
  179. // 写GIF图像描述间隔符
  180. byChar      = 0x2C;
  181. file.Write((LPSTR)&byChar,1);
  183. // 写GIF图像描述块
  184. GIFI.wLeft                = 0;
  185. GIFI.wTop                 = 0;
  186. GIFI.wWidth               = GIFCVar.wWidth;
  187. GIFI.wDepth               = GIFCVar.wDepth;
  188. GIFI.LocalFlag.PalBits    = 0x00;
  189. GIFI.LocalFlag.Reserved   = 0x00;
  190. GIFI.LocalFlag.SortFlag   = 0x00;
  191. GIFI.LocalFlag.Interlace  = (BYTE)(bInterlace ? 0x01 : 0x00);
  192. GIFI.LocalFlag.LocalPal   = 0x00;
  193. file.Write((LPSTR)&GIFI, 9);
  195. // 写GIF图像压缩数据
  196. HANDLE hSrcBuff = GlobalAlloc(GHND,(DWORD)MAX_BUFF_SIZE);
  197. GIFCVar.lpDataBuff = (LPSTR)GlobalLock(hSrcBuff);
  198. GIFCVar.lpEndBuff  = GIFCVar.lpDataBuff;
  199. GIFCVar.dwTempCode = 0UL;
  200. GIFCVar.wByteCnt   = 0;
  201. GIFCVar.wBlockNdx  = 1;
  202. GIFCVar.byLeftBits = 0x00;
  204. // 进行GIF_LZW编码
  205. EncodeGIF_LZW(lpDIBBits, file, &GIFCVar,wWidthBytes, bInterlace);
  207. // 判断是否编码成功
  208. if (GIFCVar.wByteCnt)
  209. {
  210. // 写入文件
  211. file.Write(GIFCVar.lpDataBuff, GIFCVar.wByteCnt);
  212. }
  214. // 释放内存
  215. GlobalUnlock(hSrcBuff);
  216. GlobalFree(hSrcBuff);
  218. // 写GIF Block Terminator
  219. byChar   = 0x00;
  220. file.Write((LPSTR)&byChar,1);
  222. // 写GIF文件结尾块
  223. byChar   = 0x3B;
  224. file.Write((LPSTR)&byChar,1);
  226. // 返回
  227. return TRUE;
  228. }
  230. /*************************************************************************
  231.  *
  232.  * 函数名称：
  233.  *   EncodeGIF_LZW()
  234.  *
  235.  * 参数:
  236.  *   LPSTR lpDIBBits - 指向源DIB图像指针
  237.  *   CFile& file - 要保存的文件
  238.  *   LPGIFC_VAR lpGIFCVar - 指向GIFC_VAR结构的指针
  239.  *  WORD wWidthBytes - 每行图像字节数
  240.  *  BOOL bInterlace - 是否按照交错方式保存
  241.  *
  242.  * 返回值:
  243.  *   无
  244.  *
  245.  * 说明:
  246.  *   该函数对指定图像进行GIF_LZW编码。
  247.  *
  248.  *************************************************************************/
  249. void WINAPI EncodeGIF_LZW(LPSTR lpDIBBits, CFile& file, 
  250.   LPGIFC_VAR lpGIFCVar,WORD wWidthBytes, BOOL bInterlace)
  251. {
  252. // 内存分配句柄
  253. HANDLE hTableNdx;
  254. HANDLE hPrefix;
  255. HANDLE hSuffix;
  257. // 指向字串表指针
  258. LPWORD lpwTableNdx;
  260. // 用于字串表搜索的索引
  261. LPWORD lpwPrefix;
  262. LPBYTE lpbySuffix;
  264. // 指向当前编码像素的指针
  265. LPSTR  lpImage;
  267. // 计算当前数据图像的偏移量
  268. DWORD  dwDataNdx;
  270. // LZW_CLEAR
  271. WORD   wLZW_CLEAR;
  273. // LZW_EOI
  274. WORD   wLZW_EOI;
  276. // LZW_MinCodeLen
  277. BYTE   byLZW_MinCodeLen;
  279. // 字串表索引
  280. WORD   wPreTableNdx;
  281. WORD   wNowTableNdx;
  282. WORD   wTopTableNdx;
  284. // 哈希表索引
  285. WORD   wHashNdx;
  286. WORD   wHashGap;
  287. WORD   wPrefix;
  288. WORD   wShiftBits;
  290. // 当前图像的行数
  291. WORD   wRowNum;
  293. WORD   wWidthCnt;
  295. // 循环变量
  296. WORD   wi;
  297. WORD   wj;
  299. // 交错方式存储时每次增加的行数
  300. WORD   wIncTable[5]  = { 8,8,4,2,0 }; 
  302. // 交错方式存储时起始行数
  303. WORD   wBgnTable[5]  = { 0,4,2,1,0 }; 
  305. BOOL   bStart;
  306. BYTE   bySuffix;
  307. BYTE   bySubBlock[256];
  308. BYTE   byCurrentBits;
  309. BYTE   byMask;
  310. BYTE   byChar;
  311. BYTE   byPass;
  313. // 临时字节变量
  314. BYTE   byTemp;
  316. // 给字串表分配内存
  317. hTableNdx        = GlobalAlloc(GHND,(DWORD)(MAX_HASH_SIZE<<1));
  318. hPrefix          = GlobalAlloc(GHND,(DWORD)(MAX_HASH_SIZE<<1));
  319. hSuffix          = GlobalAlloc(GHND,(DWORD)MAX_HASH_SIZE);
  321. // 锁定内存
  322. lpwTableNdx      = (LPWORD)GlobalLock(hTableNdx);
  323. lpwPrefix        = (LPWORD)GlobalLock(hPrefix);
  324. lpbySuffix       = (LPBYTE)GlobalLock(hSuffix);
  326. // 计算LZW_MinCodeLen
  327. byLZW_MinCodeLen = (BYTE)((lpGIFCVar->wBits>1) ? lpGIFCVar->wBits : 0x02);
  329. // 写GIF LZW最小代码大小
  330. file.Write((LPSTR)&byLZW_MinCodeLen,1);
  332. wRowNum          = 0;
  333. bStart           = TRUE;
  334. byPass           = 0x00;
  336. // 计算LZW_CLEAR
  337. wLZW_CLEAR       = 1 << byLZW_MinCodeLen;
  339. // 计算LZW_EOI
  340. wLZW_EOI         = wLZW_CLEAR + 1;
  342. // 初始化字串表
  343. byCurrentBits    = byLZW_MinCodeLen + (BYTE)0x01;
  344. wNowTableNdx     = wLZW_CLEAR + 2;
  345. wTopTableNdx     = 1 << byCurrentBits;
  346. for(wi=0; wi<MAX_HASH_SIZE; wi++)
  347. {
  348. // 初始化为0xFFFF
  349. *(lpwTableNdx+wi) = 0xFFFF;
  350. }
  352. // 输出LZW_CLEAR
  353. GIF_LZW_WriteCode(file, wLZW_CLEAR, (LPSTR)bySubBlock,
  354.   &byCurrentBits, lpGIFCVar);
  356. // 逐行编码
  357. for(wi=0; wi<lpGIFCVar->wDepth; wi++)
  358. {
  359. // 计算当前偏移量
  360. dwDataNdx  = (DWORD)(lpGIFCVar->wDepth - 1 - wRowNum) * (DWORD)wWidthBytes;
  362. // 指向当前行图像的指针
  363. lpImage    = (LPSTR) (((BYTE*)lpDIBBits) + dwDataNdx);
  365. wWidthCnt  = 0;
  366. wShiftBits = 8 - lpGIFCVar->wBits;
  367. byMask     = (BYTE)((lpGIFCVar->wBits==1) ? 0x80 : 0xF0);
  369. if (bStart)
  370. {
  371. // 判断是否是256色位图（一个像素一字节）
  372. if (lpGIFCVar->wBits==8)
  373. {
  374. // 256色，直接赋值即可
  375. byTemp      = *lpImage++;
  376. }
  377. else
  378. {
  379. // 非256色，需要移位获取像素值
  380. wShiftBits  = 8 - lpGIFCVar->wBits;
  381. byMask      = (BYTE)((lpGIFCVar->wBits==1) ? 0x80 : 0xF0);
  382. byTemp      = (BYTE)((*lpImage & byMask) >> wShiftBits);
  383. byMask    >>= lpGIFCVar->wBits;
  384. wShiftBits -= lpGIFCVar->wBits;
  385. }
  386. wPrefix    = (WORD)byTemp;
  387. bStart     = FALSE;
  388. wWidthCnt ++;
  389. }
  391. // 每行编码
  392. while(wWidthCnt < lpGIFCVar->wWidth)
  393. {
  394. // 判断是否是256色位图（一个像素一字节）
  395. if (lpGIFCVar->wBits==8)
  396. {
  397. // 256色，直接赋值即可
  398. byTemp = *lpImage++;
  399. }
  400. else
  401. {
  402. // 非256色，需要移位获取像素值
  403. byChar = *lpImage;
  404. byTemp = (BYTE)((byChar & byMask) >> wShiftBits);
  405. if (wShiftBits)
  406. {
  407. byMask    >>= lpGIFCVar->wBits;
  408. wShiftBits -= lpGIFCVar->wBits;
  409. }
  410. else
  411. {
  412. wShiftBits  = 8 - lpGIFCVar->wBits;
  413. byMask      = (BYTE)((lpGIFCVar->wBits==1) ? 0x80 : 0xF0);
  414. lpImage    ++;
  415. }
  416. }
  417. bySuffix   = byTemp;
  418. wWidthCnt ++;
  420. // 查找当前字符串是否存在于字串表中
  421. wHashNdx = wPrefix ^ ((WORD)bySuffix << 4);
  422. wHashGap = (wHashNdx ? (MAX_HASH_SIZE - wHashNdx) : 1);
  424. // 判断当前字符串是否在字串表中
  425. while(TRUE)
  426. {
  427. // 当前字符串不在字串表中
  428. if (*(lpwTableNdx + wHashNdx) == 0xFFFF)
  429. {
  430.    // 新字符串，退出循环
  431.    break;
  432. }
  434. // 判断是否找到该字符串
  435. if ((*(lpwPrefix+wHashNdx)  == wPrefix) &&
  436. (*(lpbySuffix+wHashNdx) == bySuffix))
  437. {
  438. // 找到，退出循环
  439. break;
  440. }
  442. // 第二哈希表
  443. if (wHashNdx < wHashGap)
  444. {
  445. wHashNdx += MAX_HASH_SIZE;
  446. }
  447. wHashNdx -= wHashGap;
  448. }
  450. // 判断是否是新字符串
  451. if (*(lpwTableNdx+wHashNdx) != 0xFFFF)
  452. {
  453. // 不是新字符串
  454. wPrefix = *(lpwTableNdx + wHashNdx);
  455.  }
  456.  else
  457.  {
  458. // 新字符串
  460. // 输出该编码
  461. GIF_LZW_WriteCode(file,wPrefix,(LPSTR)bySubBlock,
  462.    &byCurrentBits,lpGIFCVar);
  464. // 将该新字符串添加到字串表中
  465. wPreTableNdx = wNowTableNdx;
  467. // 判断是否达到最大字串表大小
  468. if (wNowTableNdx < MAX_TABLE_SIZE)
  469. {
  470. *(lpwTableNdx+wHashNdx) = wNowTableNdx++;
  471. *(lpwPrefix+wHashNdx)   = wPrefix;
  472. *(lpbySuffix+wHashNdx)  = bySuffix;
  473. }
  475. if (wPreTableNdx == wTopTableNdx)
  476. {
  477. if (byCurrentBits<12)
  478. {
  479. byCurrentBits ++;
  480. wTopTableNdx <<= 1;
  481. }
  482. else
  483. {
  484. // 字串表到达最大长度
  486. // 输出LZW_CLEAR
  487. GIF_LZW_WriteCode(file, wLZW_CLEAR, (LPSTR)bySubBlock,
  488.  &byCurrentBits,lpGIFCVar);
  490. // 重新初始化字串表
  491. byCurrentBits    = byLZW_MinCodeLen + (BYTE)0x01;
  492. wLZW_CLEAR       = 1 << byLZW_MinCodeLen;
  493. wLZW_EOI         = wLZW_CLEAR + 1;
  494. wNowTableNdx     = wLZW_CLEAR + 2;
  495. wTopTableNdx     = 1 << byCurrentBits;
  496. for(wj=0;wj<MAX_HASH_SIZE;wj++)
  497. {
  498. // 初始化为0xFFFF
  499. *(lpwTableNdx+wj) = 0xFFFF;
  500. }
  501. }
  502. }
  503. wPrefix = (WORD)bySuffix;
  504. }
  505. }
  507. // 判断是否是交错方式
  508. if (bInterlace)
  509. {
  510. // 交错方式，计算下一行位置
  511. wRowNum += wIncTable[byPass];
  512. if (wRowNum>=lpGIFCVar->wDepth)
  513. {
  514. byPass ++;
  515. wRowNum = wBgnTable[byPass];
  516. }
  517. }
  518. else
  519. {
  520. // 非交错方式，直接将行数加一即可
  521. wRowNum ++;
  522. }
  523. }
  525. // 输出当前编码
  526. GIF_LZW_WriteCode(file, wPrefix, (LPSTR)bySubBlock,
  527.   &byCurrentBits,lpGIFCVar);
  529. // 输出LZW_EOI
  530. GIF_LZW_WriteCode(file,wLZW_EOI,(LPSTR)bySubBlock,
  531.   &byCurrentBits,lpGIFCVar);
  533. if (lpGIFCVar->byLeftBits)
  534. {
  535. // 加入该字符
  536. bySubBlock[lpGIFCVar->wBlockNdx++] = (BYTE)lpGIFCVar->dwTempCode;
  538. // 判断是否超出MAX_SUBBLOCK_SIZE
  539. if (lpGIFCVar->wBlockNdx > MAX_SUBBLOCK_SIZE)
  540. {
  541. // 判断wByteCnt + 256是否超过MAX_BUFF_SIZE
  542. if ((lpGIFCVar->wByteCnt + 256) >= MAX_BUFF_SIZE)
  543. {
  544. // 输出
  545. file.Write(lpGIFCVar->lpDataBuff,
  546.   lpGIFCVar->wByteCnt);
  547. lpGIFCVar->lpEndBuff = lpGIFCVar->lpDataBuff;
  548. lpGIFCVar->wByteCnt  = 0;
  549. }
  550. bySubBlock[0]           = (BYTE)(lpGIFCVar->wBlockNdx - 1);
  551. memcpy(lpGIFCVar->lpEndBuff,(LPSTR)bySubBlock,lpGIFCVar->wBlockNdx);
  552. lpGIFCVar->lpEndBuff   += lpGIFCVar->wBlockNdx;
  553. lpGIFCVar->wByteCnt    += lpGIFCVar->wBlockNdx;
  554. lpGIFCVar->wBlockNdx    = 1;
  555. }
  556. lpGIFCVar->dwTempCode = 0UL;
  557. lpGIFCVar->byLeftBits = 0x00;
  558. }
  560. if (lpGIFCVar->wBlockNdx > 1)
  561. {
  562. // 判断wByteCnt + 256是否超过MAX_BUFF_SIZE
  563. if ((lpGIFCVar->wByteCnt + 256) >= MAX_BUFF_SIZE)
  564. {
  565. // 输出
  566. file.Write(lpGIFCVar->lpDataBuff,
  567.    lpGIFCVar->wByteCnt);
  568. lpGIFCVar->lpEndBuff = lpGIFCVar->lpDataBuff;
  569. lpGIFCVar->wByteCnt  = 0;
  570. }
  571. bySubBlock[0]           = (BYTE)(lpGIFCVar->wBlockNdx - 1);
  572. memcpy(lpGIFCVar->lpEndBuff,(LPSTR)bySubBlock,lpGIFCVar->wBlockNdx);
  573. lpGIFCVar->lpEndBuff   += lpGIFCVar->wBlockNdx;
  574. lpGIFCVar->wByteCnt    += lpGIFCVar->wBlockNdx;
  575. lpGIFCVar->wBlockNdx    = 1;
  576. }
  578. // 解除锁定
  579. GlobalUnlock(hTableNdx);
  580. GlobalUnlock(hPrefix);
  581. GlobalUnlock(hSuffix);
  583. // 释放内存
  584. GlobalFree(hTableNdx);
  585. GlobalFree(hPrefix);
  586. GlobalFree(hSuffix);
  588. // 退出
  589. return;
  590. }
  593. /*************************************************************************
  594.  *
  595.  * 函数名称：
  596.  *   GIF_LZW_WriteCode()
  597.  *
  598.  * 参数:
  599.  *   CFile& file - 要保存的文件
  600.  *  WORD wCode - 要添加的编码
  601.  *   LPSTR lpSubBlock - 子块
  602.  *  LPBYTE lpbyCurrentBits - 当前位数
  603.  *  LPGIFC_VAR lpGIFCVar - 指向GIFC_VAR结构的指针
  604.  *
  605.  * 返回值:
  606.  *   无
  607.  *
  608.  * 说明:
  609.  *   该函数用来输出一个编码。
  610.  *
  611.  *************************************************************************/
  612. void WINAPI GIF_LZW_WriteCode(CFile& file, WORD wCode, LPSTR lpSubBlock,
  613.                               LPBYTE lpbyCurrentBits,LPGIFC_VAR lpGIFCVar)
  614. {
  615. // 输出该编码
  616. lpGIFCVar->dwTempCode |= ((DWORD)wCode << lpGIFCVar->byLeftBits);
  617. lpGIFCVar->byLeftBits += (*lpbyCurrentBits);
  619. while(lpGIFCVar->byLeftBits >= 0x08)
  620. {
  621. lpSubBlock[lpGIFCVar->wBlockNdx++] = (BYTE)lpGIFCVar->dwTempCode;
  622.       
  623. // 判断是否超出MAX_SUBBLOCK_SIZE
  624. if (lpGIFCVar->wBlockNdx > MAX_SUBBLOCK_SIZE)
  625. {
  626. // 判断wByteCnt + 256是否超过MAX_BUFF_SIZE
  627. if ((lpGIFCVar->wByteCnt + 256) >= MAX_BUFF_SIZE)
  628. {
  629. // 输出
  630. file.Write(lpGIFCVar->lpDataBuff,
  631. lpGIFCVar->wByteCnt);
  632.             lpGIFCVar->lpEndBuff = lpGIFCVar->lpDataBuff;
  633.         lpGIFCVar->wByteCnt  = 0;
  634. }
  635. lpSubBlock[0]           = (BYTE)(lpGIFCVar->wBlockNdx - 1);
  636. memcpy(lpGIFCVar->lpEndBuff,lpSubBlock,lpGIFCVar->wBlockNdx);
  637. lpGIFCVar->lpEndBuff   += lpGIFCVar->wBlockNdx;
  638. lpGIFCVar->wByteCnt    += lpGIFCVar->wBlockNdx;
  639. lpGIFCVar->wBlockNdx    = 1;
  640. }
  641. lpGIFCVar->dwTempCode >>= 8;
  642. lpGIFCVar->byLeftBits  -= 0x08;
  643. }
  645. // 返回
  646. return;
  647. }
  650. /*************************************************************************
  651.  *
  652.  * 函数名称：
  653.  *   ReadGIF()
  654.  *
  655.  * 参数:
  656.  *   CFile& file        - 要读取的文件
  657.  *
  658.  * 返回值:
  659.  *   HDIB               - 成功返回DIB的句柄，否则返回NULL。
  660.  *
  661.  * 说明:
  662.  *   该函数将读取指定的GIF文件。将读取的结果保存在一个未压缩
  663.  * 编码的DIB对象中。
  664.  *
  665.  *************************************************************************/
  666. HDIB WINAPI ReadGIF(CFile& file)
  667. {
  669. // DIB句柄
  670. HDIB    hDIB;
  672. // DIB指针
  673. LPSTR    pDIB;
  675. // 指向DIB像素的指针
  676. LPSTR    lpDIBBits;
  678. // 指向BITMAPINFOHEADER的指针
  679. LPBITMAPINFOHEADER lpBIH;
  681. // 指向BITMAPINFO的指针
  682. LPBITMAPINFO       lpBI;
  684. // GIF文件头
  685. GIFHEADER          GIFH;
  687. // GIF逻辑屏幕描述块
  688. GIFSCRDESC         GIFS;
  690. // GIF图像描述块
  691. GIFIMAGE           GIFI;
  693. // GIF图像控制扩充块
  694. GIFCONTROL         GIFC;
  696. // GIF图像说明扩充块
  697. GIFPLAINTEXT       GIFP;
  699. // GIF应用程序扩充块
  700. GIFAPPLICATION     GIFA;
  702. // GIF编码参数
  703. GIFD_VAR           GIFDVar;
  705. // 颜色数目
  706. WORD               wColors;
  708. // 每行字节数
  709. WORD               wWidthBytes;
  711. // 调色板
  712. BYTE               byGIF_Pal[768];
  714. // 16色系统调色板
  715. BYTE               bySysPal16[48] = { 0,   0,   0,   0,   0, 128,
  716. 0, 128,   0,   0, 128, 128,
  717.   128,   0,   0, 128,   0, 128,
  718.   128, 128,   0, 128, 128, 128,
  719.   192, 192, 192,   0,   0, 255,
  720. 0, 255,   0,   0, 255, 255,
  721.   255,   0,   0, 255,   0, 255,
  722.   255, 255,   0, 255, 255, 255
  723.    };
  725. // DIB大小(字节数)
  726. DWORD              dwDIB_Size;
  728. // 调色板大小(字节数)
  729. WORD               wPalSize;
  731. // 字节变量
  732. BYTE               byTemp;
  734. // 内存句柄
  735. HANDLE    hSrcBuff;
  736. HANDLE             hTemp;
  738. // 内存指针
  739. LPSTR              lpTemp;
  741. // 字变量
  742. WORD               wTemp;
  744. // 循环变量
  745. WORD               wi;
  747. // 标签
  748. BYTE               byLabel;
  750. // 块大小
  751. BYTE               byBlockSize;
  753. // 读取GIF文件头
  754. file.Read((LPSTR)&GIFH, sizeof(GIFH));
  756. // 判断是否是GIF文件
  757. if (memicmp((LPSTR)GIFH.bySignature,"GIF",3) != 0)
  758. {
  759. // 非GIF文件，返回NULL
  760. return NULL;
  761. }
  763. // 判断版本号是否正确
  764. if ((memicmp((LPSTR)GIFH.byVersion,"87a",3) != 0) &&
  765. (memicmp((LPSTR)GIFH.byVersion,"89a",3) != 0))
  766. {
  767. // 不支持该版本，返回NULL
  768. return NULL;
  769. }
  771. // 读取GIF逻辑屏幕描述块
  772. file.Read((LPSTR)&GIFS, 7);
  774. // 获取调色板的位数
  775. GIFDVar.wBits = (WORD)GIFS.GlobalFlag.PalBits + 1;
  777. // 判断是否有全局调色板
  778. if (GIFS.GlobalFlag.GlobalPal)
  779. {
  780. // 赋初值
  781. memset((LPSTR)byGIF_Pal,0,768);
  783. // 全局调色板大小
  784. wPalSize = 3 * (1 << GIFDVar.wBits);
  786. // 读取全局调色板
  787. file.Read((LPSTR)byGIF_Pal,wPalSize);
  788. }
  790. // 读取下一个字节
  791. file.Read((LPSTR)&byTemp,1);
  793. // 对每一个描述块循环
  794. while(TRUE)
  795. {
  796. // 判断是否是图像描述块
  797. if (byTemp == 0x2C)
  798. {
  799. // 是图像描述块，退出循环
  800. break;
  801. }
  803. // 判断是否是GIF扩展块
  804. if (byTemp==0x21)
  805. {
  806. // 是GIF扩展块
  808. // 分配内存
  809. hTemp  = GlobalAlloc(GHND,(DWORD)MAX_BUFF_SIZE);
  811. // 锁定内存
  812. lpTemp = (LPSTR) GlobalLock(hTemp);
  814. // 读取下一个字节
  815. file.Read((LPSTR)&byLabel, 1);
  817. // 针对各种扩充块，进行分别处理
  818. switch(byLabel)
  819. {
  820. case 0xF9:
  821. {
  822. // 图像控制扩充块
  823. file.Read((LPSTR)&GIFC, 6);
  825. // 跳出
  826. break;
  827. }
  828. case 0x01:
  829. {
  830. // 图像说明扩充块
  831. file.Read((LPSTR)&GIFP,sizeof(GIFP));
  833. // 读取扩充块大小
  834. file.Read((LPSTR)&byBlockSize,1);
  836. // 当byBlockSize > 0时循环读取
  837. while(byBlockSize)
  838. {
  839. // 读取图像说明扩充块（这里没有进行任何处理）
  840. file.Read(lpTemp,byBlockSize);
  842. // 读取扩充块大小
  843. file.Read((LPSTR)&byBlockSize,1);
  844. }
  846. // 跳出
  847. break;
  848. }
  849. case 0xFE:
  850. {
  851. // 注释说明扩充块
  853. // 读取扩充块大小
  854. file.Read((LPSTR)&byBlockSize,1);
  856. // 当byBlockSize > 0时循环读取
  857. while(byBlockSize)
  858. {
  859. // 读取注释说明扩充块（这里没有进行任何处理）
  860. file.Read(lpTemp,byBlockSize);
  862. // 读取扩充块大小
  863. file.Read((LPSTR)&byBlockSize,1);
  864. }
  866. // 跳出
  867. break;
  868. }
  869. case 0xFF:
  870. {
  871. // 应用程序扩充块
  872. file.Read((LPSTR)&GIFA, sizeof(GIFA));
  874. // 读取扩充块大小
  875. file.Read((LPSTR)&byBlockSize,1);
  877. // 当byBlockSize > 0时循环读取
  878. while(byBlockSize)
  879. {
  880. // 读取应用程序扩充块（这里没有进行任何处理）
  881. file.Read(lpTemp,byBlockSize);
  883. // 读取扩充块大小
  884. file.Read((LPSTR)&byBlockSize,1);
  885. }
  887. // 跳出
  888. break;
  889. }
  890. default:
  891. {
  892. // 忽略未知的扩充块
  894. // 读取扩充块大小
  895. file.Read((LPSTR)&byBlockSize,1);
  897. // 当byBlockSize > 0时循环读取
  898. while(byBlockSize)
  899. {
  900. // 读取未知的扩充块（这里没有进行任何处理）
  901. file.Read(lpTemp,byBlockSize);
  903. // 读取扩充块大小
  904. file.Read((LPSTR)&byBlockSize,1);
  905. }
  907. // 跳出
  908. break;
  909. }
  911. // 释放内存
  912. GlobalUnlock(hTemp);
  913. GlobalFree(hTemp);
  914. }
  915. }
  917. // 读取下一个字节
  918. file.Read((LPSTR)&byTemp,1);
  919. }
  921. // 读取GIF图像描述块
  922. file.Read((LPSTR)&GIFI, 9);
  924. // 获取图像宽度
  925. GIFDVar.wWidth         = GIFI.wWidth;
  927. // 获取图像高度
  928. GIFDVar.wDepth         = GIFI.wDepth;
  930. // 判断是否有区域调色板
  931. if (GIFI.LocalFlag.LocalPal)
  932. {
  933. // 赋初值
  934. memset((LPSTR)byGIF_Pal, 0, 768);
  936. // 读取区域调色板位数
  937. GIFDVar.wBits = (WORD)GIFI.LocalFlag.PalBits + 1;
  939. // 区域调色板大小
  940. wPalSize      = 3 * (1 << GIFDVar.wBits);
  942. // 读取区域调色板
  943. file.Read((LPSTR)byGIF_Pal,wPalSize);
  944. }
  946. // 给GIFDVar成员赋值
  947. GIFDVar.wBits          = ((GIFDVar.wBits==1) ? 1 :
  948.   (GIFDVar.wBits<=4) ? 4 : 8);
  950. GIFDVar.wLineBytes     = (WORD)BYTE_WBYTES((DWORD)GIFDVar.wWidth *
  951.    (DWORD)GIFDVar.wBits);
  952. GIFDVar.bEOF           = FALSE;
  954. // 交错方式
  955. GIFDVar.bInterlace     = (GIFI.LocalFlag.Interlace ? TRUE : FALSE);
  957. // 每行字节数
  958. wWidthBytes    = (WORD)DWORD_WBYTES((DWORD)GIFDVar.wWidth *
  959.    (DWORD)GIFDVar.wBits);
  961. // 颜色数目
  962. wColors    = 1 << GIFDVar.wBits;
  964. // 调色板大小
  965. wPalSize    = wColors * sizeof(RGBQUAD);
  967. // 计算DIB长度（字节）
  968. dwDIB_Size    = sizeof(BITMAPINFOHEADER) + wPalSize
  969.  + GIFDVar.wDepth * wWidthBytes;
  971. // 为DIB分配内存
  972. hDIB = (HDIB) ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, dwDIB_Size);
  974. if (hDIB == 0)
  975. {
  976. // 内存分配失败，返回NULL。
  977. return NULL;
  978. }
  980. // 锁定
  981. pDIB = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);
  983. ///////////////////////////////////////////////////////////////////////////
  984. // 设置BITMAPINFOHEADER
  986. // 赋值
  987. lpBIH = (LPBITMAPINFOHEADER) pDIB;
  988. lpBI  = (LPBITMAPINFO) pDIB;
  990. // 给lpBIH成员赋值
  991. lpBIH->biSize = (DWORD)sizeof(BITMAPINFOHEADER);
  992. lpBIH->biWidth = (DWORD)GIFDVar.wWidth;
  993. lpBIH->biHeight = (DWORD)GIFDVar.wDepth;
  994. lpBIH->biPlanes = 1;
  995. lpBIH->biBitCount = GIFDVar.wBits;
  996. lpBIH->biCompression = BI_RGB;
  997. lpBIH->biSizeImage = (DWORD)wWidthBytes * GIFDVar.wDepth;
  998. lpBIH->biXPelsPerMeter = 0;
  999. lpBIH->biYPelsPerMeter = 0;
  1000. lpBIH->biClrUsed = wColors;
  1001. lpBIH->biClrImportant = 0;
  1003. ///////////////////////////////////////////////////////////////////////////
  1004. // 设置调色板
  1006. // 判断是否指定全局或区域调色板
  1007. if (GIFS.GlobalFlag.GlobalPal || GIFI.LocalFlag.LocalPal)
  1008. {
  1009. wTemp = 0;
  1010. for(wi=0; wi<wColors; wi++)
  1011. {
  1012. lpBI->bmiColors[wi].rgbRed      = byGIF_Pal[wTemp++];
  1013. lpBI->bmiColors[wi].rgbGreen    = byGIF_Pal[wTemp++];
  1014. lpBI->bmiColors[wi].rgbBlue     = byGIF_Pal[wTemp++];
  1015. lpBI->bmiColors[wi].rgbReserved = 0x00;
  1016. }
  1017. }
  1018. else
  1019. {
  1020. // 没有指定全局和区域调色板，采用系统调色板
  1022. // 按照颜色数目来分别给调色板赋值
  1023. switch(wColors)
  1024. {
  1025. case   2:
  1026. {
  1027. // 单色位图
  1029. lpBI->bmiColors[0].rgbRed          = 0x00;
  1030. lpBI->bmiColors[0].rgbGreen        = 0x00;
  1031. lpBI->bmiColors[0].rgbBlue         = 0x00;
  1032. lpBI->bmiColors[0].rgbReserved     = 0x00;
  1033. lpBI->bmiColors[1].rgbRed          = 0xFF;
  1034. lpBI->bmiColors[1].rgbGreen        = 0xFF;
  1035. lpBI->bmiColors[1].rgbBlue         = 0xFF;
  1036. lpBI->bmiColors[1].rgbReserved     = 0x00;
  1038. // 跳出
  1039. break;
  1040. }
  1041. case  16:
  1042. {
  1043. // 16色位图
  1045. wTemp = 0;
  1046. for(wi=0;wi<wColors;wi++)
  1047. {
  1048. lpBI->bmiColors[wi].rgbRed      = bySysPal16[wTemp++];
  1049. lpBI->bmiColors[wi].rgbGreen    = bySysPal16[wTemp++];
  1050. lpBI->bmiColors[wi].rgbBlue     = bySysPal16[wTemp++];
  1051. lpBI->bmiColors[wi].rgbReserved = 0x00;
  1052. }
  1054. // 跳出
  1055. break;
  1056. }
  1057. case 256:
  1058. {
  1059. // 256色位图
  1060. for(wi=0; wi<wColors; wi++)
  1061. {
  1062. lpBI->bmiColors[wi].rgbRed      = (BYTE)wi;
  1063. lpBI->bmiColors[wi].rgbGreen    = (BYTE)wi;
  1064. lpBI->bmiColors[wi].rgbBlue     = (BYTE)wi;
  1065. lpBI->bmiColors[wi].rgbReserved = 0x00;
  1066. }
  1068. // 跳出
  1069. break;
  1070. }
  1071. }
  1072. }
  1074. ///////////////////////////////////////////////////////////////////////////
  1075. // 解码
  1077. // 获取编码数据长度
  1078. GIFDVar.dwDataLen  = (DWORD) (file.GetLength() - file.GetPosition());
  1080. // 计算内存大小（最大不超过MAX_BUFF_SIZE）
  1081. GIFDVar.wMemLen    = ((GIFDVar.dwDataLen > (DWORD)MAX_BUFF_SIZE) ?
  1082.   (WORD)MAX_BUFF_SIZE : (WORD)GIFDVar.dwDataLen);
  1084. // 分配内存
  1085. hSrcBuff = GlobalAlloc(GHND, (DWORD)GIFDVar.wMemLen);
  1087. // 锁定内存
  1088. GIFDVar.lpDataBuff = (LPSTR)GlobalLock(hSrcBuff);
  1090. // 读取编码数据
  1091. ReadSrcData(file,&GIFDVar.wMemLen,&GIFDVar.dwDataLen,
  1092. GIFDVar.lpDataBuff,&GIFDVar.bEOF);
  1094. // 缓冲区起始位置
  1095. GIFDVar.lpBgnBuff  = GIFDVar.lpDataBuff;
  1097. // 缓冲区中止位置
  1098. GIFDVar.lpEndBuff  = GIFDVar.lpBgnBuff + GIFDVar.wMemLen;
  1100. // 计算DIB中像素位置
  1101. lpDIBBits = (LPSTR) FindDIBBits(pDIB);
  1103. // 解码
  1104. DecodeGIF_LZW(file, lpDIBBits, &GIFDVar, wWidthBytes);
  1106. // 释放内存
  1107. GlobalUnlock(hSrcBuff);
  1108. GlobalFree(hSrcBuff);
  1110. // 返回DIB句柄
  1111. return hDIB;
  1112. }
  1115. /*************************************************************************
  1116.  *
  1117.  * 函数名称：
  1118.  *   ReadSrcData()
  1119.  *
  1120.  * 参数:
  1121.  *   CFile& file - 源GIF文件
  1122.  *   LPWORD lpwMemLen - 缓冲区长度（指针）
  1123.  *   LPDWORD lpdwDataLen - 剩余数据长度（指针）
  1124.  *   LPSTR lpSrcBuff - 缓冲区指针
  1125.  *  LPBOOL lpbEOF - 结束标志
  1126.  *
  1127.  * 返回值:
  1128.  *   无
  1129.  *
  1130.  * 说明:
  1131.  *   该函数用来读取指定GIF文件中的图像编码，每次最多读取MAX_BUFF_SIZE
  1132.  * 字节，是否读完由标志lpbEOF指定。
  1133.  *
  1134.  *************************************************************************/
  1135. void WINAPI ReadSrcData(CFile& file, LPWORD lpwMemLen, LPDWORD lpdwDataLen,
  1136.                         LPSTR lpSrcBuff, LPBOOL lpbEOF)
  1137. {
  1138. // 判断数据长度是否仍然大于内存大小
  1139. if ((*lpdwDataLen) > (DWORD)(*lpwMemLen))
  1140. {
  1141. // 数据长度大于内存大小，表示没有解码完
  1143. // 数据长度减内存大小
  1144. (*lpdwDataLen) -= (DWORD)(*lpwMemLen);
  1145. }
  1146. else
  1147. {
  1148. // 数据长度不大于内存大小，表示解码将要完成
  1150. // 内存大小就是剩余数据长度
  1151. (*lpwMemLen)    = (WORD)(*lpdwDataLen);
  1153. // EOF标志设置为TRUE
  1154. (*lpbEOF)       = TRUE;
  1155. }
  1157. // 读取编码数据
  1158. file.Read(lpSrcBuff, (*lpwMemLen));
  1160. // 返回
  1161. return;
  1162. }
  1164. /*************************************************************************
  1165.  *
  1166.  * 函数名称：
  1167.  *   DecodeGIF_LZW()
  1168.  *
  1169.  * 参数:
  1170.  *   CFile& file - 源GIF文件
  1171.  *   LPSTR lpDIBBits - 指向要保存的DIB图像指针
  1172.  *   LPGIFD_VAR lpGIFDVar - 指向GIFC_VAR结构的指针
  1173.  *  WORD wWidthBytes - 每行图像字节数
  1174.  *
  1175.  * 返回值:
  1176.  *   无
  1177.  *
  1178.  * 说明:
  1179.  *   该函数对指定GIF_LZW编码数据进行解码。
  1180.  *
  1181.  *************************************************************************/
  1182. void WINAPI DecodeGIF_LZW(CFile& file, LPSTR lpDIBBits,
  1183.   LPGIFD_VAR lpGIFDVar,WORD wWidthBytes)
  1184. {
  1185. // 指向编码后图像数据的指针
  1186. BYTE * lpDst;
  1188. // 内存分配句柄
  1189. HANDLE hPrefix;
  1190. HANDLE hSuffix;
  1191. HANDLE hStack;
  1192. HANDLE hImage;
  1194. // 用于字串表搜索的索引
  1195. LPWORD lpwPrefix;
  1196. LPBYTE lpbySuffix;
  1197. LPBYTE lpbyStack;
  1198. LPBYTE lpbyStackBgn;
  1200. // 指向图像当前行解码结果的指针
  1201. LPSTR  lpImageBgn;
  1203. // 指向当前编码像素的指针
  1204. LPSTR  lpImage;
  1206. // 计算当前数据图像的偏移量
  1207. DWORD  dwDataNdx;
  1209. // LZW_CLEAR
  1210. WORD   wLZW_CLEAR;
  1212. // LZW_EOI
  1213. WORD   wLZW_EOI;
  1215. // LZW_MinCodeLen
  1216. BYTE   byLZW_MinCodeLen;
  1218. // 字串表索引
  1219. WORD   wNowTableNdx;
  1220. WORD   wTopTableNdx;
  1222. // 当前图像的行数
  1223. WORD   wRowNum;
  1225. // 计数
  1226. WORD   wWidthCnt;
  1227. WORD   wBitCnt;
  1228. WORD   wRowCnt;
  1230. // 循环变量
  1231. WORD   wi;
  1233. // 交错方式存储时每次增加的行数
  1234. WORD   wIncTable[5]  = { 8,8,4,2,0 }; 
  1236. // 交错方式存储时起始行数
  1237. WORD   wBgnTable[5]  = { 0,4,2,1,0 }; 
  1239. // 块大小
  1240. BYTE   byBlockSize;
  1242. // 块索引
  1243. BYTE   byBlockNdx;
  1245. DWORD  dwData;
  1247. // 当前编码
  1248. WORD   wCode;
  1250. // 上一个编码
  1251. WORD   wOldCode;
  1253. // 临时索引
  1254. WORD   wTempNdx;
  1256. WORD   wCodeMask[13] = {0x0000,
  1257. 0x0001,0x0003,0x0007,0x000F,
  1258. 0x001F,0x003F,0x007F,0x00FF,
  1259. 0x01FF,0x03FF,0x07FF,0x0FFF
  1260. };
  1262. BYTE   byLeftBits;
  1263. BYTE   byFirstChar;
  1264. BYTE   byCode;
  1265. BYTE   byCurrentBits;
  1266. BYTE   byPass;
  1268. // 临时字节变量
  1269. BYTE   byTempChar;
  1271. // 给字串表分配内存
  1272. hPrefix          = GlobalAlloc(GHND,(DWORD)(MAX_TABLE_SIZE<<1));
  1273. hSuffix          = GlobalAlloc(GHND,(DWORD)MAX_TABLE_SIZE);
  1274. hStack           = GlobalAlloc(GHND,(DWORD)MAX_TABLE_SIZE);
  1275. hImage           = GlobalAlloc(GHND,(DWORD)wWidthBytes);
  1277. // 锁定内存
  1278. lpwPrefix        = (LPWORD)GlobalLock(hPrefix);
  1279. lpbySuffix       = (LPBYTE)GlobalLock(hSuffix);
  1280. lpbyStack        = (LPBYTE)GlobalLock(hStack);
  1281. lpbyStackBgn     = lpbyStack;
  1282. lpImage          = (LPSTR)GlobalLock(hImage);
  1283. lpImageBgn       = lpImage;
  1285. // 读取GIF LZW最小编码大小
  1286. byLZW_MinCodeLen = *lpGIFDVar->lpBgnBuff++;
  1288. byCurrentBits    = byLZW_MinCodeLen + (BYTE)0x01;
  1290. // 计算LZW_CLEAR
  1291. wLZW_CLEAR       = 1 << byLZW_MinCodeLen;
  1293. // 计算LZW_EOI
  1294. wLZW_EOI         = wLZW_CLEAR + 1;
  1296. // 计算字串表索引
  1297. wNowTableNdx     = wLZW_CLEAR + 2;
  1298. wTopTableNdx     = 1 << byCurrentBits;
  1300. // 赋初值
  1301. dwData           = 0UL;
  1302. wBitCnt          = lpGIFDVar->wBits;
  1303. wRowNum          = 0;
  1304. wRowCnt          = 1;
  1305. wWidthCnt        = 0;
  1306. wCode            = 0;
  1307. wOldCode         = 0xFFFF;
  1308. byBlockSize      = 0x01;
  1309. byBlockNdx       = 0x00;
  1310. byLeftBits       = 0x00;
  1311. byTempChar       = 0x00;
  1312. byPass           = 0x00;
  1314. // 读取下一个编码
  1315. while(byLeftBits < byCurrentBits)
  1316. {
  1317. // 读取下一个字符
  1319. // 判断是否读完一个数据块
  1320. if (++byBlockNdx == byBlockSize)
  1321. {
  1322. // 读取下一个数据块
  1323. byBlockSize = *lpGIFDVar->lpBgnBuff++;
  1324. byBlockNdx  = 0x00;
  1326. // 判断是否读完
  1327. if ((lpGIFDVar->lpBgnBuff == lpGIFDVar->lpEndBuff) &&
  1328.     !lpGIFDVar->bEOF)
  1329. {
  1330. // 读取下一个数据块
  1331. ReadSrcData(file,&lpGIFDVar->wMemLen,
  1332. &lpGIFDVar->dwDataLen,
  1333. lpGIFDVar->lpDataBuff,&lpGIFDVar->bEOF);
  1335. // 指针重新赋值
  1336. lpGIFDVar->lpBgnBuff = lpGIFDVar->lpDataBuff;
  1337. lpGIFDVar->lpEndBuff = lpGIFDVar->lpBgnBuff + lpGIFDVar->wMemLen;
  1338. }
  1339. }
  1341. // 下一个字符
  1342. byCode      = *lpGIFDVar->lpBgnBuff++;
  1344. // 移位
  1345. dwData     |= ((DWORD)byCode << byLeftBits);
  1346. byLeftBits += 0x08;
  1348. // 判断是否读完
  1349. if ((lpGIFDVar->lpBgnBuff == lpGIFDVar->lpEndBuff) &&
  1350.     !lpGIFDVar->bEOF)
  1351. {
  1352. // 读取下一个数据块
  1353. ReadSrcData(file,&lpGIFDVar->wMemLen,
  1354. &lpGIFDVar->dwDataLen,
  1355. lpGIFDVar->lpDataBuff,&lpGIFDVar->bEOF);
  1357. // 指针重新赋值
  1358. lpGIFDVar->lpBgnBuff = lpGIFDVar->lpDataBuff;
  1359. lpGIFDVar->lpEndBuff = lpGIFDVar->lpBgnBuff + lpGIFDVar->wMemLen;
  1360. }
  1361. }
  1363. wCode       = (WORD)dwData & wCodeMask[byCurrentBits];
  1364. dwData    >>= byCurrentBits;
  1365. byLeftBits -= byCurrentBits;
  1367. // 解码
  1368. while(wCode != wLZW_EOI)
  1369. {
  1370. // 当前编码不是LZW_EOI码
  1372. // 判断是否是LZW_CLEAR码
  1373. if (wCode == wLZW_CLEAR)
  1374. {
  1375. // 是LZW_CLEAR，清除字串表
  1377. // 重新初始化字串表
  1378. for(wi = 0; wi < wLZW_CLEAR; wi++)
  1379. {
  1380. *(lpwPrefix  + wi)  = 0xFFFF;
  1381. *(lpbySuffix + wi) = (BYTE)wi;
  1382. }
  1384. for(wi = wNowTableNdx; wi < MAX_TABLE_SIZE; wi++)
  1385. {
  1386. *(lpwPrefix+wi)  = 0xFFFF;
  1387. *(lpbySuffix+wi) = 0x00;
  1388. }
  1390. byCurrentBits = byLZW_MinCodeLen + (BYTE)0x01;
  1391. wNowTableNdx  = wLZW_CLEAR + 2;
  1392. wTopTableNdx  = 1 << byCurrentBits;
  1393. wOldCode      = 0xFFFF;
  1395. // 获取下一个编码
  1396. while(byLeftBits < byCurrentBits)
  1397. {
  1398. // 读取下一个字符
  1400. // 判断是否读完一个数据块
  1401. if (++byBlockNdx == byBlockSize)
  1402. {
  1403. // 读取下一个数据块
  1404. byBlockSize = *lpGIFDVar->lpBgnBuff++;
  1405. byBlockNdx  = 0x00;
  1407. // 判断是否读完
  1408. if ((lpGIFDVar->lpBgnBuff == lpGIFDVar->lpEndBuff) &&
  1409. !lpGIFDVar->bEOF)
  1410. {
  1411. // 读取下一个数据块
  1412. ReadSrcData(file, &lpGIFDVar->wMemLen,
  1413. &lpGIFDVar->dwDataLen,
  1414. lpGIFDVar->lpDataBuff,
  1415. &lpGIFDVar->bEOF);
  1417. // 指针重新赋值
  1418. lpGIFDVar->lpBgnBuff = lpGIFDVar->lpDataBuff;
  1419. lpGIFDVar->lpEndBuff = lpGIFDVar->lpBgnBuff +
  1420.    lpGIFDVar->wMemLen;
  1421. }
  1422. }
  1423. byCode      = *lpGIFDVar->lpBgnBuff++;
  1424. dwData     |= ((DWORD)byCode << byLeftBits);
  1425. byLeftBits += 0x08;
  1427. // 判断是否读完
  1428. if ((lpGIFDVar->lpBgnBuff == lpGIFDVar->lpEndBuff) &&
  1429.  !lpGIFDVar->bEOF)
  1430. {
  1431. // 读取下一个数据块
  1432. ReadSrcData(file,&lpGIFDVar->wMemLen,
  1433. &lpGIFDVar->dwDataLen,
  1434. lpGIFDVar->lpDataBuff,&lpGIFDVar->bEOF);
  1436. // 指针重新赋值
  1437. lpGIFDVar->lpBgnBuff = lpGIFDVar->lpDataBuff;
  1438. lpGIFDVar->lpEndBuff = lpGIFDVar->lpBgnBuff + lpGIFDVar->wMemLen;
  1439. }
  1440. }
  1441. wCode       = (WORD)dwData & wCodeMask[byCurrentBits];
  1442. dwData    >>= byCurrentBits;
  1443. byLeftBits -= byCurrentBits;
  1445. // 判断编码是否为LZW_EOI
  1446. if (wCode!=wLZW_EOI)
  1447. {
  1448. // 这里没有用到lpbyStack[0]
  1449. lpbyStack  ++;
  1451. // 将数据压入堆栈
  1452. while((*(lpwPrefix+wCode)) != 0xFFFF)
  1453. {
  1454. *lpbyStack++ = *(lpbySuffix+wCode);
  1455. wCode        = *(lpwPrefix+wCode);
  1456. }
  1457. *lpbyStack  = *(lpbySuffix+wCode);
  1458. byFirstChar = *lpbyStack;
  1460. // 输出数据
  1461. while(lpbyStack>lpbyStackBgn)
  1462. {
  1463. byTempChar |= (*lpbyStack-- << (8-wBitCnt));
  1465. if (wBitCnt==8)
  1466. {
  1467. *lpImage++ = byTempChar;
  1468. byTempChar = 0x00;
  1469. wBitCnt    = lpGIFDVar->wBits;
  1470. }
  1471. else
  1472. {
  1473. wBitCnt   += lpGIFDVar->wBits;
  1474. }
  1476. wWidthCnt  ++;
  1478. if (wWidthCnt==lpGIFDVar->wWidth)
  1479. {
  1480. if (wBitCnt!=lpGIFDVar->wBits)
  1481. {
  1482. *lpImage   = byTempChar;
  1483. byTempChar = 0x00;
  1484. wBitCnt    = lpGIFDVar->wBits;
  1485. }
  1487. // 图像当前行偏移量
  1488. dwDataNdx = (DWORD)(lpGIFDVar->wDepth - 1 - wRowNum) * (DWORD)wWidthBytes;
  1490. // 图像当前行起始位置
  1491. lpDst = (BYTE *)lpDIBBits + dwDataNdx;
  1493. // 赋值
  1494. memcpy(lpDst, lpImageBgn, wWidthBytes);
  1496. lpImage   = lpImageBgn;
  1498. // 判断是否按照交错方式保存
  1499. if (lpGIFDVar->bInterlace)
  1500. {
  1501. // 交错方式
  1503. // 计算下一行的行号
  1504. wRowNum += wIncTable[byPass];
  1505. if (wRowNum >= lpGIFDVar->wDepth)
  1506. {
  1507. byPass ++;
  1508. wRowNum = wBgnTable[byPass];
  1509. }
  1510. }
  1511. else
  1512. {
  1513. // 非交错方式，行号直接加1
  1514. wRowNum ++;
  1515. }
  1516. wWidthCnt = 0;
  1517. }
  1518. }
  1519. }
  1520. }
  1521. else
  1522. {
  1523. // 这里没有用到lpbyStack[0]
  1524. lpbyStack  ++;
  1526. // 判断字符串是否在字串表中
  1527. if (wCode < wNowTableNdx)
  1528. {
  1529. // 不在字串表中
  1530. wTempNdx   = wCode;
  1531. }
  1532. else
  1533. {
  1534. // 在字串表中
  1535. wTempNdx     = wOldCode;
  1536. *lpbyStack++ = byFirstChar;
  1537. }
  1539. // 将数据压入堆栈
  1540. while((*(lpwPrefix+wTempNdx)) != 0xFFFF)
  1541. {
  1542. *lpbyStack++ = *(lpbySuffix+wTempNdx);
  1543. wTempNdx     = *(lpwPrefix+wTempNdx);
  1544. }
  1545. *lpbyStack  = *(lpbySuffix+wTempNdx);
  1546. byFirstChar = *lpbyStack;
  1548. // 将字符串添加到字串表中
  1549. *(lpwPrefix+wNowTableNdx)  = wOldCode;
  1550. *(lpbySuffix+wNowTableNdx) = byFirstChar;
  1551. if (++wNowTableNdx==wTopTableNdx && byCurrentBits<12)
  1552. {
  1553. byCurrentBits ++;
  1554. wTopTableNdx   = 1 << byCurrentBits;
  1555. }
  1557. // 输出数据
  1558. while(lpbyStack>lpbyStackBgn)
  1559. {
  1560. byTempChar |= (*lpbyStack-- << (8-wBitCnt));
  1561. if (wBitCnt==8)
  1562. {
  1563. *lpImage++ = byTempChar;
  1564. byTempChar = 0x00;
  1565. wBitCnt    = lpGIFDVar->wBits;
  1566. }
  1567. else
  1568. {
  1569. wBitCnt   += lpGIFDVar->wBits;
  1570. }
  1572. wWidthCnt  ++;
  1573. if (wWidthCnt==lpGIFDVar->wWidth)
  1574. {
  1575. if (wBitCnt!=lpGIFDVar->wBits)
  1576. {
  1577. *lpImage   = byTempChar;
  1578. byTempChar = 0x00;
  1579. wBitCnt    = lpGIFDVar->wBits;
  1580. }
  1582. // 图像当前行偏移量
  1583. dwDataNdx = (DWORD)(lpGIFDVar->wDepth - 1 - wRowNum) * (DWORD)wWidthBytes;
  1585. // 图像当前行起始位置
  1586. lpDst = (BYTE *)lpDIBBits + dwDataNdx;
  1588. // 赋值
  1589. memcpy(lpDst, lpImageBgn, wWidthBytes);
  1591. lpImage   = lpImageBgn;
  1593. // 判断是否按照交错方式保存
  1594. if (lpGIFDVar->bInterlace)
  1595. {
  1596. // 交错方式
  1598. // 计算下一行的行号
  1599. wRowNum += wIncTable[byPass];
  1600. if (wRowNum >= lpGIFDVar->wDepth)
  1601. {
  1602. byPass ++;
  1603. wRowNum = wBgnTable[byPass];
  1604. }
  1605. }
  1606. else
  1607. {
  1608. // 非交错方式，行号直接加1
  1609. wRowNum ++;
  1610. }
  1611. wWidthCnt = 0;
  1612. }
  1613. }
  1614. }
  1615. wOldCode = wCode;
  1617. // 读取下一个编码
  1618. while(byLeftBits < byCurrentBits)
  1619. {
  1620. // 读取下一个字符
  1622. // 判断是否读完一个数据块
  1623. if (++byBlockNdx == byBlockSize)
  1624. {
  1625. // 读取下一个数据块
  1626. byBlockSize = *lpGIFDVar->lpBgnBuff++;
  1627. byBlockNdx  = 0x00;
  1629. // 判断是否读完
  1630. if ((lpGIFDVar->lpBgnBuff == lpGIFDVar->lpEndBuff) &&
  1631.  !lpGIFDVar->bEOF)
  1632. {
  1633. // 读取下一个数据块
  1634. ReadSrcData(file,&lpGIFDVar->wMemLen,
  1635. &lpGIFDVar->dwDataLen,
  1636. lpGIFDVar->lpDataBuff,&lpGIFDVar->bEOF);
  1638. // 指针重新赋值
  1639. lpGIFDVar->lpBgnBuff = lpGIFDVar->lpDataBuff;
  1640. lpGIFDVar->lpEndBuff = lpGIFDVar->lpBgnBuff + lpGIFDVar->wMemLen;
  1641. }
  1642. }
  1643. byCode      = *lpGIFDVar->lpBgnBuff++;
  1644. dwData     |= ((DWORD)byCode << byLeftBits);
  1645. byLeftBits += 0x08;
  1647. // 判断是否读完
  1648. if ((lpGIFDVar->lpBgnBuff == lpGIFDVar->lpEndBuff) &&
  1649.   !lpGIFDVar->bEOF)
  1650. {
  1651. // 读取下一个数据块
  1652. ReadSrcData(file,&lpGIFDVar->wMemLen,
  1653. &lpGIFDVar->dwDataLen,
  1654. lpGIFDVar->lpDataBuff,&lpGIFDVar->bEOF);
  1656. // 指针重新赋值
  1657. lpGIFDVar->lpBgnBuff = lpGIFDVar->lpDataBuff;
  1658. lpGIFDVar->lpEndBuff = lpGIFDVar->lpBgnBuff + lpGIFDVar->wMemLen;
  1659. }
  1660. }
  1661. wCode       = (WORD)dwData & wCodeMask[byCurrentBits];
  1662. dwData    >>= byCurrentBits;
  1663. byLeftBits -= byCurrentBits;
  1664. }
  1666. // 释放内存
  1667. GlobalUnlock(hPrefix);
  1668. GlobalUnlock(hSuffix);
  1669. GlobalUnlock(hStack);
  1670. GlobalFree(hPrefix);
  1671. GlobalFree(hSuffix);
  1672. GlobalFree(hStack);
  1674. // 返回
  1675. return;
  1676. }