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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 图片显示 > 查看源码
GIFAPI.CPP
资源名称：QuickImage.rar　[点击查看]
上传用户：gzboli
上传日期：2013-04-10
资源大小：471k
文件大小：40k
源码类别：

图片显示

开发平台：

Visual C++

GIFAPI.CPP：源码内容
  1. // ************************************************************************
  2. //  文件名：GIFAPI.cpp
  3. //
  4. //  GIF(Graphics Interchange Format) API函数库：
  5. //
  6. //  DIBToGIF()          - 将指定的DIB对象（< 256色）保存为GIF文件
  7. //  EncodeGIF() - 对指定图像进行GIF_LZW编码
  8. //  WriteCodeGIF() - 输出一个编码
  9. //  ReadGIF()           - 读取GIF文件
  10. //  DecodeGIF()     - 对GIF_LZW编码结果进行解码
  11. //  ReadSrcDataGIF()       - 读取GIF_LZW编码
  12. //
  13. // ************************************************************************
  15. #include "stdafx.h"
  16. #include "GIFAPI.h"
  18. #include <io.h>
  19. #include <errno.h>
  21. #include <math.h>
  22. #include <direct.h>
  24. /*************************************************************************
  25.  *
  26.  * 函数名称：
  27.  *   DIBToGIF()
  28.  *
  29.  * 参数:
  30.  *   LPSTR lpDIB        - 指向DIB对象的指针
  31.  *   CFile& file        - 要保存的文件
  32.  *   BOOL bInterlace - 是否按照交错方式保存
  33.  *
  34.  * 返回值:
  35.  *   BOOL               - 成功返回True，否则返回False。
  36.  *
  37.  * 说明:
  38.  *   该函数将指定的DIB对象（< 256色）保存为GIF文件。
  39.  *
  40.  *************************************************************************/
  41. BOOL SaveGIF(LPCSTR lpszFileName, LPSTR lpDIB, BOOL bInterlace)
  42. {
  43. // 循环变量
  44. WORD i;
  45. WORD j;
  47. // DIB高度
  48. WORD wHeight;
  50. // DIB宽度
  51. WORD wWidth;
  53. // 指向DIB象素指针
  54. LPSTR   lpDIBBits;
  56. // GIF文件头
  57. GIFHEADER          GIFH;
  59. // GIF逻辑屏幕描述块
  60. GIFSCRDESC         GIFS;
  62. // GIF图像描述块
  63. GIFIMAGE           GIFI;
  65. // GIF编码参数
  66. GIFCONTROLPARAM    GIFControlParam;
  68. // 颜色数目
  69. WORD               wColors;
  71. // 每行字节数
  72. WORD               wWidthBytes;
  74. // 调色板
  75. BYTE               byGIF_Pal[768];
  77. // 字节变量
  78. BYTE               byChar;
  80. // 指向BITMAPINFO结构的指针（Win3.0）
  81. LPBITMAPINFO    lpbmi;
  83. // 指向BITMAPCOREINFO结构的指针
  84. LPBITMAPCOREINFO   lpbmc;
  86. // 表明是否是Win3.0 DIB的标记
  87. BOOL    bWinStyleDIB;
  89. // open file
  90. CFile file;
  91. if (! file.Open(lpszFileName, CFile::modeCreate | CFile::modeWrite))
  92. return FALSE;
  94. // 获取DIB高度
  95. wHeight = (WORD) DIBHeight(lpDIB);
  97. // 获取DIB宽度
  98. wWidth  = (WORD) DIBWidth(lpDIB);
  100. // 找到DIB图像象素起始位置
  101. lpDIBBits = (LPSTR)FindDIBBits((LPSTR)lpDIB);
  103. // 给GIFControlParam结构赋值
  104. GIFControlParam.wWidth     = wWidth;
  105. GIFControlParam.wDepth     = wHeight;
  106. GIFControlParam.wBits      = DIBBitCount(lpDIB);
  107. GIFControlParam.wLineBytes = (WORD)BYTE_WBYTES((DWORD)GIFControlParam.wWidth *
  108.    (DWORD)GIFControlParam.wBits);
  110. // 计算每行字节数
  111. wWidthBytes = (WORD)DWORD_WBYTES(wWidth * (DWORD)GIFControlParam.wBits);
  113. // 计算颜色数目
  114. wColors     = 1 << GIFControlParam.wBits;
  116. // 获取指向BITMAPINFO结构的指针（Win3.0）
  117. lpbmi = (LPBITMAPINFO)lpDIB;
  119. // 获取指向BITMAPCOREINFO结构的指针
  120. lpbmc = (LPBITMAPCOREINFO)lpDIB;
  122. // 判断是否是WIN3.0的DIB
  123. bWinStyleDIB = IS_WIN30_DIB(lpDIB);
  125. // 给调色板赋值
  126. if (bWinStyleDIB)
  127. {
  128. j = 0;
  129. for (i = 0; i < wColors; i++)
  130. {
  131. // 读取红色分量
  132. byGIF_Pal[j++] = lpbmi->bmiColors[i].rgbRed;
  134. // 读取绿色分量
  135. byGIF_Pal[j++] = lpbmi->bmiColors[i].rgbGreen;
  137. // 读取蓝色分量
  138. byGIF_Pal[j++] = lpbmi->bmiColors[i].rgbBlue;
  139. }
  140. }
  141. else
  142. {
  143. j = 0;
  144. for (i = 0; i < wColors; i++)
  145. {
  146. // 读取红色分量
  147. byGIF_Pal[j++] = lpbmc->bmciColors[i].rgbtRed;
  149. // 读取绿色分量
  150. byGIF_Pal[j++] = lpbmc->bmciColors[i].rgbtGreen;
  152. // 读取红色分量
  153. byGIF_Pal[j++] = lpbmc->bmciColors[i].rgbtBlue;
  154. }
  155. }
  157. ////////////////////////////////////////////////////////////////////////////////////////
  158. // 开始写GIF文件
  160. // 写GIF文件头
  161. GIFH.bySignature[0] = 'G';
  162. GIFH.bySignature[1] = 'I';
  163. GIFH.bySignature[2] = 'F';
  164. GIFH.byVersion[0]='8';
  165. GIFH.byVersion[1]='9';
  166. GIFH.byVersion[2]='a';
  167. file.Write((LPSTR)&GIFH, 6);
  169. // 写GIF逻辑屏幕描述块
  170. GIFS.wWidth               = GIFControlParam.wWidth;
  171. GIFS.wDepth               = GIFControlParam.wDepth;
  172. GIFS.GlobalFlag.PalBits   = (BYTE)(GIFControlParam.wBits - 1);
  173. GIFS.GlobalFlag.SortFlag  = 0x00;
  174. GIFS.GlobalFlag.ColorRes  = (BYTE)(GIFControlParam.wBits - 1);
  175. GIFS.GlobalFlag.GlobalPal = 0x01;
  176. GIFS.byBackground         = 0x00;
  177. GIFS.byAspect             = 0x00;
  178. file.Write((LPSTR)&GIFS, 7);
  180. // 写GIF全局调色板
  181. file.Write((LPSTR)byGIF_Pal,(wColors*3));
  183. // 写GIF图像描述间隔符
  184. byChar      = 0x2C;
  185. file.Write((LPSTR)&byChar,1);
  187. // 写GIF图像描述块
  188. GIFI.wLeft                = 0;
  189. GIFI.wTop                 = 0;
  190. GIFI.wWidth               = GIFControlParam.wWidth;
  191. GIFI.wDepth               = GIFControlParam.wDepth;
  192. GIFI.LocalFlag.PalBits    = 0x00;
  193. GIFI.LocalFlag.Reserved   = 0x00;
  194. GIFI.LocalFlag.SortFlag   = 0x00;
  195. GIFI.LocalFlag.Interlace  = (BYTE)(bInterlace ? 0x01 : 0x00);
  196. GIFI.LocalFlag.LocalPal   = 0x00;
  197. file.Write((LPSTR)&GIFI, 9);
  199. // 写GIF图像压缩数据
  200. HANDLE hSrcBuff = GlobalAlloc(GHND,(DWORD)MAX_BUFF_SIZE);
  201. GIFControlParam.lpDataBuff = (LPSTR)GlobalLock(hSrcBuff);
  202. GIFControlParam.lpEndBuff  = GIFControlParam.lpDataBuff;
  203. GIFControlParam.dwTempCode = 0UL;
  204. GIFControlParam.wByteCnt   = 0;
  205. GIFControlParam.wBlockNdx  = 1;
  206. GIFControlParam.byLeftBits = 0x00;
  208. // 进行GIF_LZW编码
  209. EncodeGIF(file, lpDIBBits, &GIFControlParam,wWidthBytes, bInterlace);
  211. // 判断是否编码成功
  212. if (GIFControlParam.wByteCnt)
  213. {
  214. // 写入文件
  215. file.Write(GIFControlParam.lpDataBuff, GIFControlParam.wByteCnt);
  216. }
  218. // 释放内存
  219. GlobalUnlock(hSrcBuff);
  220. GlobalFree(hSrcBuff);
  222. // 写GIF Block Terminator
  223. byChar   = 0x00;
  224. file.Write((LPSTR)&byChar,1);
  226. // 写GIF文件结尾块
  227. byChar   = 0x3B;
  228. file.Write((LPSTR)&byChar,1);
  230. // 返回
  231. return TRUE;
  232. }
  234. /*************************************************************************
  235.  *
  236.  * 函数名称：
  237.  *   EncodeGIF()
  238.  *
  239.  * 参数:
  240.  *   LPSTR lpDIBBits - 指向源DIB图像指针
  241.  *   CFile& file - 要保存的文件
  242.  *   LPGIFCONTROLPARAM lpGIFControlParam - 指向GIFCONTROLPARAM结构的指针
  243.  *  WORD wWidthBytes - 每行图像字节数
  244.  *  BOOL bInterlace - 是否按照交错方式保存
  245.  *
  246.  * 返回值:
  247.  *   无
  248.  *
  249.  * 说明:
  250.  *   该函数对指定图像进行GIF_LZW编码。
  251.  *
  252.  *************************************************************************/
  253. void EncodeGIF(CFile& file, LPSTR lpDIBBits, 
  254.   LPGIFCONTROLPARAM lpGIFControlParam,WORD wWidthBytes, BOOL bInterlace)
  255. {
  256. // 内存分配句柄
  257. HANDLE hTableNdx;
  258. HANDLE hPrefix;
  259. HANDLE hSuffix;
  261. // 指向字串表指针
  262. LPWORD lpwTableNdx;
  264. // 用于字串表搜索的索引
  265. LPWORD lpwPrefix;
  266. LPBYTE lpbySuffix;
  268. // 指向当前编码像素的指针
  269. LPSTR  lpImage;
  271. // 计算当前数据图像的偏移量
  272. DWORD  dwDataNdx;
  274. // LZW_CLEAR
  275. WORD   wLZW_CLEAR;
  277. // LZW_EOI
  278. WORD   wLZW_EOI;
  280. // LZW_MinCodeLen
  281. BYTE   byLZW_MinCodeLen;
  283. // 字串表索引
  284. WORD   wPreTableNdx;
  285. WORD   wNowTableNdx;
  286. WORD   wTopTableNdx;
  288. // 哈希表索引
  289. WORD   wHashNdx;
  290. WORD   wHashGap;
  291. WORD   wPrefix;
  292. WORD   wShiftBits;
  294. // 当前图像的行数
  295. WORD   wRowNum;
  297. WORD   wWidthCnt;
  299. // 循环变量
  300. WORD   wi;
  301. WORD   wj;
  303. // 交错方式存储时每次增加的行数
  304. WORD   wIncTable[5]  = { 8,8,4,2,0 }; 
  306. // 交错方式存储时起始行数
  307. WORD   wBgnTable[5]  = { 0,4,2,1,0 }; 
  309. BOOL   bStart;
  310. BYTE   bySuffix;
  311. BYTE   bySubBlock[256];
  312. BYTE   byCurrentBits;
  313. BYTE   byMask;
  314. BYTE   byChar;
  315. BYTE   byPass;
  317. // 临时字节变量
  318. BYTE   byTemp;
  320. // 给字串表分配内存
  321. hTableNdx        = GlobalAlloc(GHND,(DWORD)(MAX_HASH_SIZE<<1));
  322. hPrefix          = GlobalAlloc(GHND,(DWORD)(MAX_HASH_SIZE<<1));
  323. hSuffix          = GlobalAlloc(GHND,(DWORD)MAX_HASH_SIZE);
  325. // 锁定内存
  326. lpwTableNdx      = (LPWORD)GlobalLock(hTableNdx);
  327. lpwPrefix        = (LPWORD)GlobalLock(hPrefix);
  328. lpbySuffix       = (LPBYTE)GlobalLock(hSuffix);
  330. // 计算LZW_MinCodeLen
  331. byLZW_MinCodeLen = (BYTE)((lpGIFControlParam->wBits>1) ? lpGIFControlParam->wBits : 0x02);
  333. // 写GIF LZW最小代码大小
  334. file.Write((LPSTR)&byLZW_MinCodeLen,1);
  336. wRowNum          = 0;
  337. bStart           = TRUE;
  338. byPass           = 0x00;
  340. // 计算LZW_CLEAR
  341. wLZW_CLEAR       = 1 << byLZW_MinCodeLen;
  343. // 计算LZW_EOI
  344. wLZW_EOI         = wLZW_CLEAR + 1;
  346. // 初始化字串表
  347. byCurrentBits    = byLZW_MinCodeLen + (BYTE)0x01;
  348. wNowTableNdx     = wLZW_CLEAR + 2;
  349. wTopTableNdx     = 1 << byCurrentBits;
  350. for(wi=0; wi<MAX_HASH_SIZE; wi++)
  351. {
  352. // 初始化为0xFFFF
  353. *(lpwTableNdx+wi) = 0xFFFF;
  354. }
  356. // 输出LZW_CLEAR
  357. WriteCodeGIF(file, wLZW_CLEAR, (LPSTR)bySubBlock,
  358.   &byCurrentBits, lpGIFControlParam);
  360. // 逐行编码
  361. for(wi=0; wi<lpGIFControlParam->wDepth; wi++)
  362. {
  363. // 计算当前偏移量
  364. dwDataNdx  = (DWORD)(lpGIFControlParam->wDepth - 1 - wRowNum) * (DWORD)wWidthBytes;
  366. // 指向当前行图像的指针
  367. lpImage    = (LPSTR) (((BYTE*)lpDIBBits) + dwDataNdx);
  369. wWidthCnt  = 0;
  370. wShiftBits = 8 - lpGIFControlParam->wBits;
  371. byMask     = (BYTE)((lpGIFControlParam->wBits==1) ? 0x80 : 0xF0);
  373. if (bStart)
  374. {
  375. // 判断是否是256色位图（一个像素一字节）
  376. if (lpGIFControlParam->wBits==8)
  377. {
  378. // 256色，直接赋值即可
  379. byTemp      = *lpImage++;
  380. }
  381. else
  382. {
  383. // 非256色，需要移位获取像素值
  384. wShiftBits  = 8 - lpGIFControlParam->wBits;
  385. byMask      = (BYTE)((lpGIFControlParam->wBits==1) ? 0x80 : 0xF0);
  386. byTemp      = (BYTE)((*lpImage & byMask) >> wShiftBits);
  387. byMask    >>= lpGIFControlParam->wBits;
  388. wShiftBits -= lpGIFControlParam->wBits;
  389. }
  390. wPrefix    = (WORD)byTemp;
  391. bStart     = FALSE;
  392. wWidthCnt ++;
  393. }
  395. // 每行编码
  396. while(wWidthCnt < lpGIFControlParam->wWidth)
  397. {
  398. // 判断是否是256色位图（一个像素一字节）
  399. if (lpGIFControlParam->wBits==8)
  400. {
  401. // 256色，直接赋值即可
  402. byTemp = *lpImage++;
  403. }
  404. else
  405. {
  406. // 非256色，需要移位获取像素值
  407. byChar = *lpImage;
  408. byTemp = (BYTE)((byChar & byMask) >> wShiftBits);
  409. if (wShiftBits)
  410. {
  411. byMask    >>= lpGIFControlParam->wBits;
  412. wShiftBits -= lpGIFControlParam->wBits;
  413. }
  414. else
  415. {
  416. wShiftBits  = 8 - lpGIFControlParam->wBits;
  417. byMask      = (BYTE)((lpGIFControlParam->wBits==1) ? 0x80 : 0xF0);
  418. lpImage    ++;
  419. }
  420. }
  421. bySuffix   = byTemp;
  422. wWidthCnt ++;
  424. // 查找当前字符串是否存在于字串表中
  425. wHashNdx = wPrefix ^ ((WORD)bySuffix << 4);
  426. wHashGap = (wHashNdx ? (MAX_HASH_SIZE - wHashNdx) : 1);
  428. // 判断当前字符串是否在字串表中
  429. while(TRUE)
  430. {
  431. // 当前字符串不在字串表中
  432. if (*(lpwTableNdx + wHashNdx) == 0xFFFF)
  433. {
  434.    // 新字符串，退出循环
  435.    break;
  436. }
  438. // 判断是否找到该字符串
  439. if ((*(lpwPrefix+wHashNdx)  == wPrefix) &&
  440. (*(lpbySuffix+wHashNdx) == bySuffix))
  441. {
  442. // 找到，退出循环
  443. break;
  444. }
  446. // 第二哈希表
  447. if (wHashNdx < wHashGap)
  448. {
  449. wHashNdx += MAX_HASH_SIZE;
  450. }
  451. wHashNdx -= wHashGap;
  452. }
  454. // 判断是否是新字符串
  455. if (*(lpwTableNdx+wHashNdx) != 0xFFFF)
  456. {
  457. // 不是新字符串
  458. wPrefix = *(lpwTableNdx + wHashNdx);
  459.  }
  460.  else
  461.  {
  462. // 新字符串
  464. // 输出该编码
  465. WriteCodeGIF(file,wPrefix,(LPSTR)bySubBlock,
  466.    &byCurrentBits,lpGIFControlParam);
  468. // 将该新字符串添加到字串表中
  469. wPreTableNdx = wNowTableNdx;
  471. // 判断是否达到最大字串表大小
  472. if (wNowTableNdx < MAX_TABLE_SIZE)
  473. {
  474. *(lpwTableNdx+wHashNdx) = wNowTableNdx++;
  475. *(lpwPrefix+wHashNdx)   = wPrefix;
  476. *(lpbySuffix+wHashNdx)  = bySuffix;
  477. }
  479. if (wPreTableNdx == wTopTableNdx)
  480. {
  481. if (byCurrentBits<12)
  482. {
  483. byCurrentBits ++;
  484. wTopTableNdx <<= 1;
  485. }
  486. else
  487. {
  488. // 字串表到达最大长度
  490. // 输出LZW_CLEAR
  491. WriteCodeGIF(file, wLZW_CLEAR, (LPSTR)bySubBlock,
  492.  &byCurrentBits,lpGIFControlParam);
  494. // 重新初始化字串表
  495. byCurrentBits    = byLZW_MinCodeLen + (BYTE)0x01;
  496. wLZW_CLEAR       = 1 << byLZW_MinCodeLen;
  497. wLZW_EOI         = wLZW_CLEAR + 1;
  498. wNowTableNdx     = wLZW_CLEAR + 2;
  499. wTopTableNdx     = 1 << byCurrentBits;
  500. for(wj=0;wj<MAX_HASH_SIZE;wj++)
  501. {
  502. // 初始化为0xFFFF
  503. *(lpwTableNdx+wj) = 0xFFFF;
  504. }
  505. }
  506. }
  507. wPrefix = (WORD)bySuffix;
  508. }
  509. }
  511. // 判断是否是交错方式
  512. if (bInterlace)
  513. {
  514. // 交错方式，计算下一行位置
  515. wRowNum += wIncTable[byPass];
  516. if (wRowNum>=lpGIFControlParam->wDepth)
  517. {
  518. byPass ++;
  519. wRowNum = wBgnTable[byPass];
  520. }
  521. }
  522. else
  523. {
  524. // 非交错方式，直接将行数加一即可
  525. wRowNum ++;
  526. }
  527. }
  529. // 输出当前编码
  530. WriteCodeGIF(file, wPrefix, (LPSTR)bySubBlock,
  531.   &byCurrentBits,lpGIFControlParam);
  533. // 输出LZW_EOI
  534. WriteCodeGIF(file,wLZW_EOI,(LPSTR)bySubBlock,
  535.   &byCurrentBits,lpGIFControlParam);
  537. if (lpGIFControlParam->byLeftBits)
  538. {
  539. // 加入该字符
  540. bySubBlock[lpGIFControlParam->wBlockNdx++] = (BYTE)lpGIFControlParam->dwTempCode;
  542. // 判断是否超出MAX_SUBBLOCK_SIZE
  543. if (lpGIFControlParam->wBlockNdx > MAX_SUBBLOCK_SIZE)
  544. {
  545. // 判断wByteCnt + 256是否超过MAX_BUFF_SIZE
  546. if ((lpGIFControlParam->wByteCnt + 256) >= MAX_BUFF_SIZE)
  547. {
  548. // 输出
  549. file.Write(lpGIFControlParam->lpDataBuff,
  550.   lpGIFControlParam->wByteCnt);
  551. lpGIFControlParam->lpEndBuff = lpGIFControlParam->lpDataBuff;
  552. lpGIFControlParam->wByteCnt  = 0;
  553. }
  554. bySubBlock[0]           = (BYTE)(lpGIFControlParam->wBlockNdx - 1);
  555. memcpy(lpGIFControlParam->lpEndBuff,(LPSTR)bySubBlock,lpGIFControlParam->wBlockNdx);
  556. lpGIFControlParam->lpEndBuff   += lpGIFControlParam->wBlockNdx;
  557. lpGIFControlParam->wByteCnt    += lpGIFControlParam->wBlockNdx;
  558. lpGIFControlParam->wBlockNdx    = 1;
  559. }
  560. lpGIFControlParam->dwTempCode = 0UL;
  561. lpGIFControlParam->byLeftBits = 0x00;
  562. }
  564. if (lpGIFControlParam->wBlockNdx > 1)
  565. {
  566. // 判断wByteCnt + 256是否超过MAX_BUFF_SIZE
  567. if ((lpGIFControlParam->wByteCnt + 256) >= MAX_BUFF_SIZE)
  568. {
  569. // 输出
  570. file.Write(lpGIFControlParam->lpDataBuff,
  571.    lpGIFControlParam->wByteCnt);
  572. lpGIFControlParam->lpEndBuff = lpGIFControlParam->lpDataBuff;
  573. lpGIFControlParam->wByteCnt  = 0;
  574. }
  575. bySubBlock[0]           = (BYTE)(lpGIFControlParam->wBlockNdx - 1);
  576. memcpy(lpGIFControlParam->lpEndBuff,(LPSTR)bySubBlock,lpGIFControlParam->wBlockNdx);
  577. lpGIFControlParam->lpEndBuff   += lpGIFControlParam->wBlockNdx;
  578. lpGIFControlParam->wByteCnt    += lpGIFControlParam->wBlockNdx;
  579. lpGIFControlParam->wBlockNdx    = 1;
  580. }
  582. // 解除锁定
  583. GlobalUnlock(hTableNdx);
  584. GlobalUnlock(hPrefix);
  585. GlobalUnlock(hSuffix);
  587. // 释放内存
  588. GlobalFree(hTableNdx);
  589. GlobalFree(hPrefix);
  590. GlobalFree(hSuffix);
  592. // 退出
  593. return;
  594. }
  597. /*************************************************************************
  598.  *
  599.  * 函数名称：
  600.  *   WriteCodeGIF()
  601.  *
  602.  * 参数:
  603.  *   CFile& file - 要保存的文件
  604.  *  WORD wCode - 要添加的编码
  605.  *   LPSTR lpSubBlock - 子块
  606.  *  LPBYTE lpbyCurrentBits - 当前位数
  607.  *  LPGIFCONTROLPARAM lpGIFControlParam - 指向GIFCONTROLPARAM结构的指针
  608.  *
  609.  * 返回值:
  610.  *   无
  611.  *
  612.  * 说明:
  613.  *   该函数用来输出一个编码。
  614.  *
  615.  *************************************************************************/
  616. void WriteCodeGIF(CFile& file, WORD wCode, LPSTR lpSubBlock,
  617.                               LPBYTE lpbyCurrentBits,LPGIFCONTROLPARAM lpGIFControlParam)
  618. {
  619. // 输出该编码
  620. lpGIFControlParam->dwTempCode |= ((DWORD)wCode << lpGIFControlParam->byLeftBits);
  621. lpGIFControlParam->byLeftBits += (*lpbyCurrentBits);
  623. while(lpGIFControlParam->byLeftBits >= 0x08)
  624. {
  625. lpSubBlock[lpGIFControlParam->wBlockNdx++] = (BYTE)lpGIFControlParam->dwTempCode;
  626.       
  627. // 判断是否超出MAX_SUBBLOCK_SIZE
  628. if (lpGIFControlParam->wBlockNdx > MAX_SUBBLOCK_SIZE)
  629. {
  630. // 判断wByteCnt + 256是否超过MAX_BUFF_SIZE
  631. if ((lpGIFControlParam->wByteCnt + 256) >= MAX_BUFF_SIZE)
  632. {
  633. // 输出
  634. file.Write(lpGIFControlParam->lpDataBuff,
  635. lpGIFControlParam->wByteCnt);
  636.             lpGIFControlParam->lpEndBuff = lpGIFControlParam->lpDataBuff;
  637.         lpGIFControlParam->wByteCnt  = 0;
  638. }
  639. lpSubBlock[0]           = (BYTE)(lpGIFControlParam->wBlockNdx - 1);
  640. memcpy(lpGIFControlParam->lpEndBuff,lpSubBlock,lpGIFControlParam->wBlockNdx);
  641. lpGIFControlParam->lpEndBuff   += lpGIFControlParam->wBlockNdx;
  642. lpGIFControlParam->wByteCnt    += lpGIFControlParam->wBlockNdx;
  643. lpGIFControlParam->wBlockNdx    = 1;
  644. }
  645. lpGIFControlParam->dwTempCode >>= 8;
  646. lpGIFControlParam->byLeftBits  -= 0x08;
  647. }
  649. // 返回
  650. return;
  651. }
  654. /*************************************************************************
  655.  *
  656.  * 函数名称：
  657.  *   ReadGIF()
  658.  *
  659.  * 参数:
  660.  *   CFile& file        - 要读取的文件
  661.  *
  662.  * 返回值:
  663.  *   HDIB               - 成功返回DIB的句柄，否则返回NULL。
  664.  *
  665.  * 说明:
  666.  *   该函数将读取指定的GIF文件。将读取的结果保存在一个未压缩
  667.  * 编码的DIB对象中。
  668.  *
  669.  *************************************************************************/
  670. HDIB ReadGIF(LPCTSTR lpszFileName)
  671. {
  673. // DIB句柄
  674. HDIB    hDIB;
  676. // DIB指针
  677. LPSTR    pDIB;
  679. // 指向DIB像素的指针
  680. LPSTR    lpDIBBits;
  682. // 指向BITMAPINFOHEADER的指针
  683. LPBITMAPINFOHEADER lpBIH;
  685. // 指向BITMAPINFO的指针
  686. LPBITMAPINFO       lpBI;
  688. // GIF文件头
  689. GIFHEADER          GIFH;
  691. // GIF逻辑屏幕描述块
  692. GIFSCRDESC         GIFS;
  694. // GIF图像描述块
  695. GIFIMAGE           GIFI;
  697. // GIF图像控制扩充块
  698. GIFCONTROL         GIFC;
  700. // GIF图像说明扩充块
  701. GIFPLAINTEXT       GIFP;
  703. // GIF应用程序扩充块
  704. GIFAPPLICATION     GIFA;
  706. // GIF编码参数
  707. GIFDATAPARAM           GIFDataParam;
  709. // 颜色数目
  710. WORD               wColors;
  712. // 每行字节数
  713. WORD               wWidthBytes;
  715. // 调色板
  716. BYTE               byGIF_Pal[768];
  718. // 16色系统调色板
  719. BYTE               bySysPal16[48] = { 0,   0,   0,   0,   0, 128,
  720. 0, 128,   0,   0, 128, 128,
  721.   128,   0,   0, 128,   0, 128,
  722.   128, 128,   0, 128, 128, 128,
  723.   192, 192, 192,   0,   0, 255,
  724. 0, 255,   0,   0, 255, 255,
  725.   255,   0,   0, 255,   0, 255,
  726.   255, 255,   0, 255, 255, 255
  727.    };
  729. // DIB大小(字节数)
  730. DWORD              dwDIB_Size;
  732. // 调色板大小(字节数)
  733. WORD               wPalSize;
  735. // 字节变量
  736. BYTE               byTemp;
  738. // 内存句柄
  739. HANDLE    hSrcBuff;
  740. HANDLE             hTemp;
  742. // 内存指针
  743. LPSTR              lpTemp;
  745. // 字变量
  746. WORD               wTemp;
  748. // 循环变量
  749. WORD               wi;
  751. // 标签
  752. BYTE               byLabel;
  754. // 块大小
  755. BYTE               byBlockSize;
  757. // open file
  758. CFile file;
  759. if (! file.Open(lpszFileName, CFile::modeRead))
  760. return FALSE;
  762. // 读取GIF文件头
  763. file.Read((LPSTR)&GIFH, sizeof(GIFH));
  765. // 判断是否是GIF文件
  766. if (memicmp((LPSTR)GIFH.bySignature,"GIF",3) != 0)
  767. {
  768. // 非GIF文件，返回NULL
  769. return NULL;
  770. }
  772. // 判断版本号是否正确
  773. if ((memicmp((LPSTR)GIFH.byVersion,"87a",3) != 0) &&
  774. (memicmp((LPSTR)GIFH.byVersion,"89a",3) != 0))
  775. {
  776. // 不支持该版本，返回NULL
  777. AfxMessageBox("Not support format!");
  778. return NULL;
  779. }
  781. // 读取GIF逻辑屏幕描述块
  782. file.Read((LPSTR)&GIFS, 7);
  784. // 获取调色板的位数
  785. GIFDataParam.wBits = (WORD)GIFS.GlobalFlag.PalBits + 1;
  787. // 判断是否有全局调色板
  788. if (GIFS.GlobalFlag.GlobalPal)
  789. {
  790. // 赋初值
  791. memset((LPSTR)byGIF_Pal,0,768);
  793. // 全局调色板大小
  794. wPalSize = 3 * (1 << GIFDataParam.wBits);
  796. // 读取全局调色板
  797. file.Read((LPSTR)byGIF_Pal,wPalSize);
  798. }
  800. // 读取下一个字节
  801. file.Read((LPSTR)&byTemp,1);
  803. // 对每一个描述块循环
  804. while(TRUE)
  805. {
  806. // 判断是否是图像描述块
  807. if (byTemp == 0x2C)
  808. {
  809. // 是图像描述块，退出循环
  810. break;
  811. }
  813. // 判断是否是GIF扩展块
  814. if (byTemp==0x21)
  815. {
  816. // 是GIF扩展块
  818. // 分配内存
  819. hTemp  = GlobalAlloc(GHND,(DWORD)MAX_BUFF_SIZE);
  821. // 锁定内存
  822. lpTemp = (LPSTR) GlobalLock(hTemp);
  824. // 读取下一个字节
  825. file.Read((LPSTR)&byLabel, 1);
  827. // 针对各种扩充块，进行分别处理
  828. switch(byLabel)
  829. {
  830. case 0xF9:
  831. {
  832. // 图像控制扩充块
  833. file.Read((LPSTR)&GIFC, 6);
  835. // 跳出
  836. break;
  837. }
  838. case 0x01:
  839. {
  840. // 图像说明扩充块
  841. file.Read((LPSTR)&GIFP,sizeof(GIFP));
  843. // 读取扩充块大小
  844. file.Read((LPSTR)&byBlockSize,1);
  846. // 当byBlockSize > 0时循环读取
  847. while(byBlockSize)
  848. {
  849. // 读取图像说明扩充块（这里没有进行任何处理）
  850. file.Read(lpTemp,byBlockSize);
  852. // 读取扩充块大小
  853. file.Read((LPSTR)&byBlockSize,1);
  854. }
  856. // 跳出
  857. break;
  858. }
  859. case 0xFE:
  860. {
  861. // 注释说明扩充块
  863. // 读取扩充块大小
  864. file.Read((LPSTR)&byBlockSize,1);
  866. // 当byBlockSize > 0时循环读取
  867. while(byBlockSize)
  868. {
  869. // 读取注释说明扩充块（这里没有进行任何处理）
  870. file.Read(lpTemp,byBlockSize);
  872. // 读取扩充块大小
  873. file.Read((LPSTR)&byBlockSize,1);
  874. }
  876. // 跳出
  877. break;
  878. }
  879. case 0xFF:
  880. {
  881. // 应用程序扩充块
  882. file.Read((LPSTR)&GIFA, sizeof(GIFA));
  884. // 读取扩充块大小
  885. file.Read((LPSTR)&byBlockSize,1);
  887. // 当byBlockSize > 0时循环读取
  888. while(byBlockSize)
  889. {
  890. // 读取应用程序扩充块（这里没有进行任何处理）
  891. file.Read(lpTemp,byBlockSize);
  893. // 读取扩充块大小
  894. file.Read((LPSTR)&byBlockSize,1);
  895. }
  897. // 跳出
  898. break;
  899. }
  900. default:
  901. {
  902. // 忽略未知的扩充块
  904. // 读取扩充块大小
  905. file.Read((LPSTR)&byBlockSize,1);
  907. // 当byBlockSize > 0时循环读取
  908. while(byBlockSize)
  909. {
  910. // 读取未知的扩充块（这里没有进行任何处理）
  911. file.Read(lpTemp,byBlockSize);
  913. // 读取扩充块大小
  914. file.Read((LPSTR)&byBlockSize,1);
  915. }
  917. // 跳出
  918. break;
  919. }
  921. // 释放内存
  922. GlobalUnlock(hTemp);
  923. GlobalFree(hTemp);
  924. }
  925. }
  927. // 读取下一个字节
  928. file.Read((LPSTR)&byTemp,1);
  929. }
  931. // 读取GIF图像描述块
  932. file.Read((LPSTR)&GIFI, 9);
  934. // 获取图像宽度
  935. GIFDataParam.wWidth         = GIFI.wWidth;
  937. // 获取图像高度
  938. GIFDataParam.wDepth         = GIFI.wDepth;
  940. // 判断是否有区域调色板
  941. if (GIFI.LocalFlag.LocalPal)
  942. {
  943. // 赋初值
  944. memset((LPSTR)byGIF_Pal, 0, 768);
  946. // 读取区域调色板位数
  947. GIFDataParam.wBits = (WORD)GIFI.LocalFlag.PalBits + 1;
  949. // 区域调色板大小
  950. wPalSize      = 3 * (1 << GIFDataParam.wBits);
  952. // 读取区域调色板
  953. file.Read((LPSTR)byGIF_Pal,wPalSize);
  954. }
  956. // 给GIFDataParam成员赋值
  957. GIFDataParam.wBits          = ((GIFDataParam.wBits==1) ? 1 :
  958.   (GIFDataParam.wBits<=4) ? 4 : 8);
  960. GIFDataParam.wLineBytes     = (WORD)BYTE_WBYTES((DWORD)GIFDataParam.wWidth *
  961.    (DWORD)GIFDataParam.wBits);
  962. GIFDataParam.bEOF           = FALSE;
  964. // 交错方式
  965. GIFDataParam.bInterlace     = (GIFI.LocalFlag.Interlace ? TRUE : FALSE);
  967. // 每行字节数
  968. wWidthBytes    = (WORD)DWORD_WBYTES((DWORD)GIFDataParam.wWidth *
  969.    (DWORD)GIFDataParam.wBits);
  971. // 颜色数目
  972. wColors    = 1 << GIFDataParam.wBits;
  974. // 调色板大小
  975. wPalSize    = wColors * sizeof(RGBQUAD);
  977. // 计算DIB长度（字节）
  978. dwDIB_Size    = sizeof(BITMAPINFOHEADER) + wPalSize
  979.  + GIFDataParam.wDepth * wWidthBytes;
  981. // 为DIB分配内存
  982. hDIB = (HDIB) ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, dwDIB_Size);
  984. if (hDIB == 0)
  985. {
  986. // 内存分配失败，返回NULL。
  987. return NULL;
  988. }
  990. // 锁定
  991. pDIB = (LPSTR) ::GlobalLock((HGLOBAL) hDIB);
  993. ///////////////////////////////////////////////////////////////////////////
  994. // 设置BITMAPINFOHEADER
  996. // 赋值
  997. lpBIH = (LPBITMAPINFOHEADER) pDIB;
  998. lpBI  = (LPBITMAPINFO) pDIB;
  1000. // 给lpBIH成员赋值
  1001. lpBIH->biSize = (DWORD)sizeof(BITMAPINFOHEADER);
  1002. lpBIH->biWidth = (DWORD)GIFDataParam.wWidth;
  1003. lpBIH->biHeight = (DWORD)GIFDataParam.wDepth;
  1004. lpBIH->biPlanes = 1;
  1005. lpBIH->biBitCount = GIFDataParam.wBits;
  1006. lpBIH->biCompression = BI_RGB;
  1007. lpBIH->biSizeImage = (DWORD)wWidthBytes * GIFDataParam.wDepth;
  1008. lpBIH->biXPelsPerMeter = 0;
  1009. lpBIH->biYPelsPerMeter = 0;
  1010. lpBIH->biClrUsed = wColors;
  1011. lpBIH->biClrImportant = 0;
  1013. ///////////////////////////////////////////////////////////////////////////
  1014. // 设置调色板
  1016. // 判断是否指定全局或区域调色板
  1017. if (GIFS.GlobalFlag.GlobalPal || GIFI.LocalFlag.LocalPal)
  1018. {
  1019. wTemp = 0;
  1020. for(wi=0; wi<wColors; wi++)
  1021. {
  1022. lpBI->bmiColors[wi].rgbRed      = byGIF_Pal[wTemp++];
  1023. lpBI->bmiColors[wi].rgbGreen    = byGIF_Pal[wTemp++];
  1024. lpBI->bmiColors[wi].rgbBlue     = byGIF_Pal[wTemp++];
  1025. lpBI->bmiColors[wi].rgbReserved = 0x00;
  1026. }
  1027. }
  1028. else
  1029. {
  1030. // 没有指定全局和区域调色板，采用系统调色板
  1032. // 按照颜色数目来分别给调色板赋值
  1033. switch(wColors)
  1034. {
  1035. case   2:
  1036. {
  1037. // 单色位图
  1039. lpBI->bmiColors[0].rgbRed          = 0x00;
  1040. lpBI->bmiColors[0].rgbGreen        = 0x00;
  1041. lpBI->bmiColors[0].rgbBlue         = 0x00;
  1042. lpBI->bmiColors[0].rgbReserved     = 0x00;
  1043. lpBI->bmiColors[1].rgbRed          = 0xFF;
  1044. lpBI->bmiColors[1].rgbGreen        = 0xFF;
  1045. lpBI->bmiColors[1].rgbBlue         = 0xFF;
  1046. lpBI->bmiColors[1].rgbReserved     = 0x00;
  1048. // 跳出
  1049. break;
  1050. }
  1051. case  16:
  1052. {
  1053. // 16色位图
  1055. wTemp = 0;
  1056. for(wi=0;wi<wColors;wi++)
  1057. {
  1058. lpBI->bmiColors[wi].rgbRed      = bySysPal16[wTemp++];
  1059. lpBI->bmiColors[wi].rgbGreen    = bySysPal16[wTemp++];
  1060. lpBI->bmiColors[wi].rgbBlue     = bySysPal16[wTemp++];
  1061. lpBI->bmiColors[wi].rgbReserved = 0x00;
  1062. }
  1064. // 跳出
  1065. break;
  1066. }
  1067. case 256:
  1068. {
  1069. // 256色位图
  1070. for(wi=0; wi<wColors; wi++)
  1071. {
  1072. lpBI->bmiColors[wi].rgbRed      = (BYTE)wi;
  1073. lpBI->bmiColors[wi].rgbGreen    = (BYTE)wi;
  1074. lpBI->bmiColors[wi].rgbBlue     = (BYTE)wi;
  1075. lpBI->bmiColors[wi].rgbReserved = 0x00;
  1076. }
  1078. // 跳出
  1079. break;
  1080. }
  1081. }
  1082. }
  1084. ///////////////////////////////////////////////////////////////////////////
  1085. // 解码
  1087. // 获取编码数据长度
  1088. GIFDataParam.dwDataLen  = (DWORD) (file.GetLength() - file.GetPosition());
  1090. // 计算内存大小（最大不超过MAX_BUFF_SIZE）
  1091. GIFDataParam.wMemLen    = ((GIFDataParam.dwDataLen > (DWORD)MAX_BUFF_SIZE) ?
  1092.   (WORD)MAX_BUFF_SIZE : (WORD)GIFDataParam.dwDataLen);
  1094. // 分配内存
  1095. hSrcBuff = GlobalAlloc(GHND, (DWORD)GIFDataParam.wMemLen);
  1097. // 锁定内存
  1098. GIFDataParam.lpDataBuff = (LPSTR)GlobalLock(hSrcBuff);
  1100. // 读取编码数据
  1101. ReadSrcDataGIF(file,&GIFDataParam.wMemLen,&GIFDataParam.dwDataLen,
  1102. GIFDataParam.lpDataBuff,&GIFDataParam.bEOF);
  1104. // 缓冲区起始位置
  1105. GIFDataParam.lpBgnBuff  = GIFDataParam.lpDataBuff;
  1107. // 缓冲区中止位置
  1108. GIFDataParam.lpEndBuff  = GIFDataParam.lpBgnBuff + GIFDataParam.wMemLen;
  1110. // 计算DIB中像素位置
  1111. lpDIBBits = (LPSTR) FindDIBBits(pDIB);
  1113. // 解码
  1114. DecodeGIF(file, lpDIBBits, &GIFDataParam, wWidthBytes);
  1116. // 释放内存
  1117. GlobalUnlock(hSrcBuff);
  1118. GlobalFree(hSrcBuff);
  1120. // 返回DIB句柄
  1121. return hDIB;
  1122. }
  1125. /*************************************************************************
  1126.  *
  1127.  * 函数名称：
  1128.  *   ReadSrcDataGIF()
  1129.  *
  1130.  * 参数:
  1131.  *   CFile& file - 源GIF文件
  1132.  *   LPWORD lpwMemLen - 缓冲区长度（指针）
  1133.  *   LPDWORD lpdwDataLen - 剩余数据长度（指针）
  1134.  *   LPSTR lpSrcBuff - 缓冲区指针
  1135.  *  LPBOOL lpbEOF - 结束标志
  1136.  *
  1137.  * 返回值:
  1138.  *   无
  1139.  *
  1140.  * 说明:
  1141.  *   该函数用来读取指定GIF文件中的图像编码，每次最多读取MAX_BUFF_SIZE
  1142.  * 字节，是否读完由标志lpbEOF指定。
  1143.  *
  1144.  *************************************************************************/
  1145. void ReadSrcDataGIF(CFile& file, LPWORD lpwMemLen, LPDWORD lpdwDataLen,
  1146.                         LPSTR lpSrcBuff, LPBOOL lpbEOF)
  1147. {
  1148. // 判断数据长度是否仍然大于内存大小
  1149. if ((*lpdwDataLen) > (DWORD)(*lpwMemLen))
  1150. {
  1151. // 数据长度大于内存大小，表示没有解码完
  1153. // 数据长度减内存大小
  1154. (*lpdwDataLen) -= (DWORD)(*lpwMemLen);
  1155. }
  1156. else
  1157. {
  1158. // 数据长度不大于内存大小，表示解码将要完成
  1160. // 内存大小就是剩余数据长度
  1161. (*lpwMemLen)    = (WORD)(*lpdwDataLen);
  1163. // EOF标志设置为TRUE
  1164. (*lpbEOF)       = TRUE;
  1165. }
  1167. // 读取编码数据
  1168. file.Read(lpSrcBuff, (*lpwMemLen));
  1170. // 返回
  1171. return;
  1172. }
  1174. /*************************************************************************
  1175.  *
  1176.  * 函数名称：
  1177.  *   DecodeGIF()
  1178.  *
  1179.  * 参数:
  1180.  *   CFile& file - 源GIF文件
  1181.  *   LPSTR lpDIBBits - 指向要保存的DIB图像指针
  1182.  *   LPGIFDATAPARAM lpGIFDataParam - 指向GIFCONTROLPARAM结构的指针
  1183.  *  WORD wWidthBytes - 每行图像字节数
  1184.  *
  1185.  * 返回值:
  1186.  *   无
  1187.  *
  1188.  * 说明:
  1189.  *   该函数对指定GIF_LZW编码数据进行解码。
  1190.  *
  1191.  *************************************************************************/
  1192. void DecodeGIF(CFile& file, LPSTR lpDIBBits,
  1193.   LPGIFDATAPARAM lpGIFDataParam,WORD wWidthBytes)
  1194. {
  1195. // 指向编码后图像数据的指针
  1196. BYTE * lpDst;
  1198. // 内存分配句柄
  1199. HANDLE hPrefix;
  1200. HANDLE hSuffix;
  1201. HANDLE hStack;
  1202. HANDLE hImage;
  1204. // 用于字串表搜索的索引
  1205. LPWORD lpwPrefix;
  1206. LPBYTE lpbySuffix;
  1207. LPBYTE lpbyStack;
  1208. LPBYTE lpbyStackBgn;
  1210. // 指向图像当前行解码结果的指针
  1211. LPSTR  lpImageBgn;
  1213. // 指向当前编码像素的指针
  1214. LPSTR  lpImage;
  1216. // 计算当前数据图像的偏移量
  1217. DWORD  dwDataNdx;
  1219. // LZW_CLEAR
  1220. WORD   wLZW_CLEAR;
  1222. // LZW_EOI
  1223. WORD   wLZW_EOI;
  1225. // LZW_MinCodeLen
  1226. BYTE   byLZW_MinCodeLen;
  1228. // 字串表索引
  1229. WORD   wNowTableNdx;
  1230. WORD   wTopTableNdx;
  1232. // 当前图像的行数
  1233. WORD   wRowNum;
  1235. // 计数
  1236. WORD   wWidthCnt;
  1237. WORD   wBitCnt;
  1238. WORD   wRowCnt;
  1240. // 循环变量
  1241. WORD   wi;
  1243. // 交错方式存储时每次增加的行数
  1244. WORD   wIncTable[5]  = { 8,8,4,2,0 }; 
  1246. // 交错方式存储时起始行数
  1247. WORD   wBgnTable[5]  = { 0,4,2,1,0 }; 
  1249. // 块大小
  1250. BYTE   byBlockSize;
  1252. // 块索引
  1253. BYTE   byBlockNdx;
  1255. DWORD  dwData;
  1257. // 当前编码
  1258. WORD   wCode;
  1260. // 上一个编码
  1261. WORD   wOldCode;
  1263. // 临时索引
  1264. WORD   wTempNdx;
  1266. WORD   wCodeMask[13] = {0x0000,
  1267. 0x0001,0x0003,0x0007,0x000F,
  1268. 0x001F,0x003F,0x007F,0x00FF,
  1269. 0x01FF,0x03FF,0x07FF,0x0FFF
  1270. };
  1272. BYTE   byLeftBits;
  1273. BYTE   byFirstChar;
  1274. BYTE   byCode;
  1275. BYTE   byCurrentBits;
  1276. BYTE   byPass;
  1278. // 临时字节变量
  1279. BYTE   byTempChar;
  1281. // 给字串表分配内存
  1282. hPrefix          = GlobalAlloc(GHND,(DWORD)(MAX_TABLE_SIZE<<1));
  1283. hSuffix          = GlobalAlloc(GHND,(DWORD)MAX_TABLE_SIZE);
  1284. hStack           = GlobalAlloc(GHND,(DWORD)MAX_TABLE_SIZE);
  1285. hImage           = GlobalAlloc(GHND,(DWORD)wWidthBytes);
  1287. // 锁定内存
  1288. lpwPrefix        = (LPWORD)GlobalLock(hPrefix);
  1289. lpbySuffix       = (LPBYTE)GlobalLock(hSuffix);
  1290. lpbyStack        = (LPBYTE)GlobalLock(hStack);
  1291. lpbyStackBgn     = lpbyStack;
  1292. lpImage          = (LPSTR)GlobalLock(hImage);
  1293. lpImageBgn       = lpImage;
  1295. // 读取GIF LZW最小编码大小
  1296. byLZW_MinCodeLen = *lpGIFDataParam->lpBgnBuff++;
  1298. byCurrentBits    = byLZW_MinCodeLen + (BYTE)0x01;
  1300. // 计算LZW_CLEAR
  1301. wLZW_CLEAR       = 1 << byLZW_MinCodeLen;
  1303. // 计算LZW_EOI
  1304. wLZW_EOI         = wLZW_CLEAR + 1;
  1306. // 计算字串表索引
  1307. wNowTableNdx     = wLZW_CLEAR + 2;
  1308. wTopTableNdx     = 1 << byCurrentBits;
  1310. // 赋初值
  1311. dwData           = 0UL;
  1312. wBitCnt          = lpGIFDataParam->wBits;
  1313. wRowNum          = 0;
  1314. wRowCnt          = 1;
  1315. wWidthCnt        = 0;
  1316. wCode            = 0;
  1317. wOldCode         = 0xFFFF;
  1318. byBlockSize      = 0x01;
  1319. byBlockNdx       = 0x00;
  1320. byLeftBits       = 0x00;
  1321. byTempChar       = 0x00;
  1322. byPass           = 0x00;
  1324. // 读取下一个编码
  1325. while(byLeftBits < byCurrentBits)
  1326. {
  1327. // 读取下一个字符
  1329. // 判断是否读完一个数据块
  1330. if (++byBlockNdx == byBlockSize)
  1331. {
  1332. // 读取下一个数据块
  1333. byBlockSize = *lpGIFDataParam->lpBgnBuff++;
  1334. byBlockNdx  = 0x00;
  1336. // 判断是否读完
  1337. if ((lpGIFDataParam->lpBgnBuff == lpGIFDataParam->lpEndBuff) &&
  1338.     !lpGIFDataParam->bEOF)
  1339. {
  1340. // 读取下一个数据块
  1341. ReadSrcDataGIF(file,&lpGIFDataParam->wMemLen,
  1342. &lpGIFDataParam->dwDataLen,
  1343. lpGIFDataParam->lpDataBuff,&lpGIFDataParam->bEOF);
  1345. // 指针重新赋值
  1346. lpGIFDataParam->lpBgnBuff = lpGIFDataParam->lpDataBuff;
  1347. lpGIFDataParam->lpEndBuff = lpGIFDataParam->lpBgnBuff + lpGIFDataParam->wMemLen;
  1348. }
  1349. }
  1351. // 下一个字符
  1352. byCode      = *lpGIFDataParam->lpBgnBuff++;
  1354. // 移位
  1355. dwData     |= ((DWORD)byCode << byLeftBits);
  1356. byLeftBits += 0x08;
  1358. // 判断是否读完
  1359. if ((lpGIFDataParam->lpBgnBuff == lpGIFDataParam->lpEndBuff) &&
  1360.     !lpGIFDataParam->bEOF)
  1361. {
  1362. // 读取下一个数据块
  1363. ReadSrcDataGIF(file,&lpGIFDataParam->wMemLen,
  1364. &lpGIFDataParam->dwDataLen,
  1365. lpGIFDataParam->lpDataBuff,&lpGIFDataParam->bEOF);
  1367. // 指针重新赋值
  1368. lpGIFDataParam->lpBgnBuff = lpGIFDataParam->lpDataBuff;
  1369. lpGIFDataParam->lpEndBuff = lpGIFDataParam->lpBgnBuff + lpGIFDataParam->wMemLen;
  1370. }
  1371. }
  1373. wCode       = (WORD)dwData & wCodeMask[byCurrentBits];
  1374. dwData    >>= byCurrentBits;
  1375. byLeftBits -= byCurrentBits;
  1377. // 解码
  1378. while(wCode != wLZW_EOI)
  1379. {
  1380. // 当前编码不是LZW_EOI码
  1382. // 判断是否是LZW_CLEAR码
  1383. if (wCode == wLZW_CLEAR)
  1384. {
  1385. // 是LZW_CLEAR，清除字串表
  1387. // 重新初始化字串表
  1388. for(wi = 0; wi < wLZW_CLEAR; wi++)
  1389. {
  1390. *(lpwPrefix  + wi)  = 0xFFFF;
  1391. *(lpbySuffix + wi) = (BYTE)wi;
  1392. }
  1394. for(wi = wNowTableNdx; wi < MAX_TABLE_SIZE; wi++)
  1395. {
  1396. *(lpwPrefix+wi)  = 0xFFFF;
  1397. *(lpbySuffix+wi) = 0x00;
  1398. }
  1400. byCurrentBits = byLZW_MinCodeLen + (BYTE)0x01;
  1401. wNowTableNdx  = wLZW_CLEAR + 2;
  1402. wTopTableNdx  = 1 << byCurrentBits;
  1403. wOldCode      = 0xFFFF;
  1405. // 获取下一个编码
  1406. while(byLeftBits < byCurrentBits)
  1407. {
  1408. // 读取下一个字符
  1410. // 判断是否读完一个数据块
  1411. if (++byBlockNdx == byBlockSize)
  1412. {
  1413. // 读取下一个数据块
  1414. byBlockSize = *lpGIFDataParam->lpBgnBuff++;
  1415. byBlockNdx  = 0x00;
  1417. // 判断是否读完
  1418. if ((lpGIFDataParam->lpBgnBuff == lpGIFDataParam->lpEndBuff) &&
  1419. !lpGIFDataParam->bEOF)
  1420. {
  1421. // 读取下一个数据块
  1422. ReadSrcDataGIF(file, &lpGIFDataParam->wMemLen,
  1423. &lpGIFDataParam->dwDataLen,
  1424. lpGIFDataParam->lpDataBuff,
  1425. &lpGIFDataParam->bEOF);
  1427. // 指针重新赋值
  1428. lpGIFDataParam->lpBgnBuff = lpGIFDataParam->lpDataBuff;
  1429. lpGIFDataParam->lpEndBuff = lpGIFDataParam->lpBgnBuff +
  1430.    lpGIFDataParam->wMemLen;
  1431. }
  1432. }
  1433. byCode      = *lpGIFDataParam->lpBgnBuff++;
  1434. dwData     |= ((DWORD)byCode << byLeftBits);
  1435. byLeftBits += 0x08;
  1437. // 判断是否读完
  1438. if ((lpGIFDataParam->lpBgnBuff == lpGIFDataParam->lpEndBuff) &&
  1439.  !lpGIFDataParam->bEOF)
  1440. {
  1441. // 读取下一个数据块
  1442. ReadSrcDataGIF(file,&lpGIFDataParam->wMemLen,
  1443. &lpGIFDataParam->dwDataLen,
  1444. lpGIFDataParam->lpDataBuff,&lpGIFDataParam->bEOF);
  1446. // 指针重新赋值
  1447. lpGIFDataParam->lpBgnBuff = lpGIFDataParam->lpDataBuff;
  1448. lpGIFDataParam->lpEndBuff = lpGIFDataParam->lpBgnBuff + lpGIFDataParam->wMemLen;
  1449. }
  1450. }
  1451. wCode       = (WORD)dwData & wCodeMask[byCurrentBits];
  1452. dwData    >>= byCurrentBits;
  1453. byLeftBits -= byCurrentBits;
  1455. // 判断编码是否为LZW_EOI
  1456. if (wCode!=wLZW_EOI)
  1457. {
  1458. // 这里没有用到lpbyStack[0]
  1459. lpbyStack  ++;
  1461. // 将数据压入堆栈
  1462. while((*(lpwPrefix+wCode)) != 0xFFFF)
  1463. {
  1464. *lpbyStack++ = *(lpbySuffix+wCode);
  1465. wCode        = *(lpwPrefix+wCode);
  1466. }
  1467. *lpbyStack  = *(lpbySuffix+wCode);
  1468. byFirstChar = *lpbyStack;
  1470. // 输出数据
  1471. while(lpbyStack>lpbyStackBgn)
  1472. {
  1473. byTempChar |= (*lpbyStack-- << (8-wBitCnt));
  1475. if (wBitCnt==8)
  1476. {
  1477. *lpImage++ = byTempChar;
  1478. byTempChar = 0x00;
  1479. wBitCnt    = lpGIFDataParam->wBits;
  1480. }
  1481. else
  1482. {
  1483. wBitCnt   += lpGIFDataParam->wBits;
  1484. }
  1486. wWidthCnt  ++;
  1488. if (wWidthCnt==lpGIFDataParam->wWidth)
  1489. {
  1490. if (wBitCnt!=lpGIFDataParam->wBits)
  1491. {
  1492. *lpImage   = byTempChar;
  1493. byTempChar = 0x00;
  1494. wBitCnt    = lpGIFDataParam->wBits;
  1495. }
  1497. // 图像当前行偏移量
  1498. dwDataNdx = (DWORD)(lpGIFDataParam->wDepth - 1 - wRowNum) * (DWORD)wWidthBytes;
  1500. // 图像当前行起始位置
  1501. lpDst = (BYTE *)lpDIBBits + dwDataNdx;
  1503. // 赋值
  1504. memcpy(lpDst, lpImageBgn, wWidthBytes);
  1506. lpImage   = lpImageBgn;
  1508. // 判断是否按照交错方式保存
  1509. if (lpGIFDataParam->bInterlace)
  1510. {
  1511. // 交错方式
  1513. // 计算下一行的行号
  1514. wRowNum += wIncTable[byPass];
  1515. if (wRowNum >= lpGIFDataParam->wDepth)
  1516. {
  1517. byPass ++;
  1518. wRowNum = wBgnTable[byPass];
  1519. }
  1520. }
  1521. else
  1522. {
  1523. // 非交错方式，行号直接加1
  1524. wRowNum ++;
  1525. }
  1526. wWidthCnt = 0;
  1527. }
  1528. }
  1529. }
  1530. }
  1531. else
  1532. {
  1533. // 这里没有用到lpbyStack[0]
  1534. lpbyStack  ++;
  1536. // 判断字符串是否在字串表中
  1537. if (wCode < wNowTableNdx)
  1538. {
  1539. // 不在字串表中
  1540. wTempNdx   = wCode;
  1541. }
  1542. else
  1543. {
  1544. // 在字串表中
  1545. wTempNdx     = wOldCode;
  1546. *lpbyStack++ = byFirstChar;
  1547. }
  1549. // 将数据压入堆栈
  1550. while((*(lpwPrefix+wTempNdx)) != 0xFFFF)
  1551. {
  1552. *lpbyStack++ = *(lpbySuffix+wTempNdx);
  1553. wTempNdx     = *(lpwPrefix+wTempNdx);
  1554. }
  1555. *lpbyStack  = *(lpbySuffix+wTempNdx);
  1556. byFirstChar = *lpbyStack;
  1558. // 将字符串添加到字串表中
  1559. *(lpwPrefix+wNowTableNdx)  = wOldCode;
  1560. *(lpbySuffix+wNowTableNdx) = byFirstChar;
  1561. if (++wNowTableNdx==wTopTableNdx && byCurrentBits<12)
  1562. {
  1563. byCurrentBits ++;
  1564. wTopTableNdx   = 1 << byCurrentBits;
  1565. }
  1567. // 输出数据
  1568. while(lpbyStack>lpbyStackBgn)
  1569. {
  1570. byTempChar |= (*lpbyStack-- << (8-wBitCnt));
  1571. if (wBitCnt==8)
  1572. {
  1573. *lpImage++ = byTempChar;
  1574. byTempChar = 0x00;
  1575. wBitCnt    = lpGIFDataParam->wBits;
  1576. }
  1577. else
  1578. {
  1579. wBitCnt   += lpGIFDataParam->wBits;
  1580. }
  1582. wWidthCnt  ++;
  1583. if (wWidthCnt==lpGIFDataParam->wWidth)
  1584. {
  1585. if (wBitCnt!=lpGIFDataParam->wBits)
  1586. {
  1587. *lpImage   = byTempChar;
  1588. byTempChar = 0x00;
  1589. wBitCnt    = lpGIFDataParam->wBits;
  1590. }
  1592. // 图像当前行偏移量
  1593. dwDataNdx = (DWORD)(lpGIFDataParam->wDepth - 1 - wRowNum) * (DWORD)wWidthBytes;
  1595. // 图像当前行起始位置
  1596. lpDst = (BYTE *)lpDIBBits + dwDataNdx;
  1598. // 赋值
  1599. memcpy(lpDst, lpImageBgn, wWidthBytes);
  1601. lpImage   = lpImageBgn;
  1603. // 判断是否按照交错方式保存
  1604. if (lpGIFDataParam->bInterlace)
  1605. {
  1606. // 交错方式
  1608. // 计算下一行的行号
  1609. wRowNum += wIncTable[byPass];
  1610. if (wRowNum >= lpGIFDataParam->wDepth)
  1611. {
  1612. byPass ++;
  1613. wRowNum = wBgnTable[byPass];
  1614. }
  1615. }
  1616. else
  1617. {
  1618. // 非交错方式，行号直接加1
  1619. wRowNum ++;
  1620. }
  1621. wWidthCnt = 0;
  1622. }
  1623. }
  1624. }
  1625. wOldCode = wCode;
  1627. // 读取下一个编码
  1628. while(byLeftBits < byCurrentBits)
  1629. {
  1630. // 读取下一个字符
  1632. // 判断是否读完一个数据块
  1633. if (++byBlockNdx == byBlockSize)
  1634. {
  1635. // 读取下一个数据块
  1636. byBlockSize = *lpGIFDataParam->lpBgnBuff++;
  1637. byBlockNdx  = 0x00;
  1639. // 判断是否读完
  1640. if ((lpGIFDataParam->lpBgnBuff == lpGIFDataParam->lpEndBuff) &&
  1641.  !lpGIFDataParam->bEOF)
  1642. {
  1643. // 读取下一个数据块
  1644. ReadSrcDataGIF(file,&lpGIFDataParam->wMemLen,
  1645. &lpGIFDataParam->dwDataLen,
  1646. lpGIFDataParam->lpDataBuff,&lpGIFDataParam->bEOF);
  1648. // 指针重新赋值
  1649. lpGIFDataParam->lpBgnBuff = lpGIFDataParam->lpDataBuff;
  1650. lpGIFDataParam->lpEndBuff = lpGIFDataParam->lpBgnBuff + lpGIFDataParam->wMemLen;
  1651. }
  1652. }
  1653. byCode      = *lpGIFDataParam->lpBgnBuff++;
  1654. dwData     |= ((DWORD)byCode << byLeftBits);
  1655. byLeftBits += 0x08;
  1657. // 判断是否读完
  1658. if ((lpGIFDataParam->lpBgnBuff == lpGIFDataParam->lpEndBuff) &&
  1659.   !lpGIFDataParam->bEOF)
  1660. {
  1661. // 读取下一个数据块
  1662. ReadSrcDataGIF(file,&lpGIFDataParam->wMemLen,
  1663. &lpGIFDataParam->dwDataLen,
  1664. lpGIFDataParam->lpDataBuff,&lpGIFDataParam->bEOF);
  1666. // 指针重新赋值
  1667. lpGIFDataParam->lpBgnBuff = lpGIFDataParam->lpDataBuff;
  1668. lpGIFDataParam->lpEndBuff = lpGIFDataParam->lpBgnBuff + lpGIFDataParam->wMemLen;
  1669. }
  1670. }
  1671. wCode       = (WORD)dwData & wCodeMask[byCurrentBits];
  1672. dwData    >>= byCurrentBits;
  1673. byLeftBits -= byCurrentBits;
  1674. }
  1676. // 释放内存
  1677. GlobalUnlock(hPrefix);
  1678. GlobalUnlock(hSuffix);
  1679. GlobalUnlock(hStack);
  1680. GlobalFree(hPrefix);
  1681. GlobalFree(hSuffix);
  1682. GlobalFree(hStack);
  1684. // 返回
  1685. return;
  1686. }