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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图象 > 查看源码
GifModule.cpp
资源名称：isee_code01231.zip　[点击查看]
上传用户：yatsl7111
上传日期：2007-01-08
资源大小：1433k
文件大小：47k
源码类别：

图形图象

开发平台：

Visual C++

GifModule.cpp：源码内容
  1. /********************************************************************
  3. GifModule.cpp - ISee图像浏览器—GIF图像读写模块实现文件
  4.           
  5.     版权所有(C) 2000 VCHelp-coPathway-ISee workgroup member - Sam, YZ
  7.     这一程序是自由软件，你可以遵照自由软件基金会出版的GNU 通用公共许
  8. 可证条款来修改和重新发布这一程序。或者用许可证的第二版，或者（根
  9. 据你的选择）用任何更新的版本。
  11.     发布这一程序的目的是希望它有用，但没有任何担保。甚至没有适合特定
  12. 目地的隐含的担保。更详细的情况请参阅GNU通用公共许可证。
  14.     你应该已经和程序一起收到一份GNU通用公共许可证的副本（本目录
  15. GPL.TXT文件）。如果还没有，写信给：
  16.     The Free Software Foundation, Inc.,  675  Mass Ave,  Cambridge,
  17.     MA02139,  USA
  19. 如果你在使用本软件时有什么问题或建议，用以下地址可以与我们取得联
  20. 系：
  21. http://isee.126.com
  22. http://www.vchelp.net
  23. 或：
  24. iseesoft@china.com
  26. 原创人    ：Sam (http://go.163.com/~program2000/)
  27. 第二编写人：YZ (http://isee.126.com/  or  yzfree@sina.com)
  29. 文件版本：
  30. Build 00901
  31. Date  2000-9-1
  33. GIF图像文件格式版权声明：
  34. ---------------------------------------------------------------
  35. The Graphics Interchange Format(c) is the Copyright property of
  36. CompuServe Incorporated. GIF(sm) is a Service Mark property of
  37. CompuServe Incorporated.
  38. ---------------------------------------------------------------
  40. ********************************************************************/
  42. #include "stdafx.h"
  43. #include "GifModule.h"
  45. #ifdef _DEBUG
  46. #define new DEBUG_NEW
  47. #undef THIS_FILE
  48. static char THIS_FILE[] = __FILE__;
  49. #endif
  51. // 全局变量定义
  53. GIFINFO m_GifInfo;
  54. LZWTABLE LZWTable[LZWTABLESIZE];
  56. CPtrList m_ImageList;
  58. RGBQUAD m_GlobalPal[256]; // 全局调色板
  59. RGBQUAD m_CurRgbQuad[256]; // 当前的局部调色板
  60. int m_CurPalSize; // 当前调色板项数（针对于局部调色板）
  61. int m_CurDM; // 当前的处置方法
  62. int m_CurUserInput; // 当前的用户输入标志
  63. short m_CurTColorIndex; // 当前的透明色索引号（-1表示无效）
  64. WORD m_CurDelayTime; // 当前的延迟时间（0表示没有延时）
  65. BOOL m_CurSaveMode; // 当前的图像存储模式
  66. WORD m_CurX,m_CurY; // 当前图像在虚拟屏幕中的位置
  67. WORD m_CurWidth,m_CurHeight; // 当前图像的宽度、高度
  69. int m_CurImgIndex; // 当前图像的序号（0基）
  70. LPSUBIMGBLOCK   m_pSubimgHead; // 子图像链表的头
  71. LPSUBIMGBLOCK   m_pSubimgTail; // 子图像链表的尾
  74. static char ModuleProcessImgType[]="GIF"; // 本模块能处理的图像类型
  75. static char WriterList[]="Sam, YZ"; // 本模块的作者列表
  76. static char WriterMess[]="我喜欢自由软件，它大大的减少了重复代码的开发^_^";
  77. // 作者留言
  79. static char GIF87a[]="GIF87a";
  80. static char GIF89a[]="GIF89a";
  82. //
  83. // Note!
  84. //
  85. // If this DLL is dynamically linked against the MFC
  86. // DLLs, any functions exported from this DLL which
  87. // call into MFC must have the AFX_MANAGE_STATE macro
  88. // added at the very beginning of the function.
  89. //
  90. // For example:
  91. //
  92. // extern "C" BOOL PASCAL EXPORT ExportedFunction()
  93. // {
  94. // AFX_MANAGE_STATE(AfxGetStaticModuleState());
  95. // // normal function body here
  96. // }
  97. //
  98. // It is very important that this macro appear in each
  99. // function, prior to any calls into MFC.  This means that
  100. // it must appear as the first statement within the 
  101. // function, even before any object variable declarations
  102. // as their constructors may generate calls into the MFC
  103. // DLL.
  104. //
  105. // Please see MFC Technical Notes 33 and 58 for additional
  106. // details.
  107. //
  109. // 在图像读写模块中，如果想分配内存，请使用API函数GlobalAlloc()
  110. // ，如果想释放内存请使用GlobalFree()函数。不要使用诸如：new
  111. // 、malloc()等函数。这是为了使各模块之间可以异地释放内存。
  112. //
  113. //
  115. /////////////////////////////////////////////////////////////////////////////
  116. // CGifModuleApp
  118. BEGIN_MESSAGE_MAP(CGifModuleApp, CWinApp)
  119. //{{AFX_MSG_MAP(CGifModuleApp)
  120. // NOTE - the ClassWizard will add and remove mapping macros here.
  121. //    DO NOT EDIT what you see in these blocks of generated code!
  122. //}}AFX_MSG_MAP
  123. END_MESSAGE_MAP()
  125. /////////////////////////////////////////////////////////////////////////////
  126. // CGifModuleApp construction
  128. CGifModuleApp::CGifModuleApp()
  129. {
  130. ::ZeroMemory((PVOID)&m_GifInfo, sizeof(GIFINFO));
  131. ::ZeroMemory((PVOID)LZWTable, sizeof(LZWTABLE)*LZWTABLESIZE);
  133. PALETTEENTRY syspal[256];
  135. // 提取当前系统的调色板数据
  136. HWND hWnd = ::GetDesktopWindow();
  137. HDC  hDC  = ::GetDC(hWnd);
  138. ::GetSystemPaletteEntries(hDC, 0, 256, (LPPALETTEENTRY)syspal);
  139. ::ReleaseDC(hWnd, hDC);
  141. // 初始化全局调色板
  142. for (int i=0;i<256;i++)
  143. {
  144. m_GlobalPal[i].rgbRed = syspal[i].peRed;
  145. m_GlobalPal[i].rgbGreen = syspal[i].peGreen;
  146. m_GlobalPal[i].rgbBlue = syspal[i].peBlue;
  147. m_GlobalPal[i].rgbReserved = 0;
  148. }
  150. m_CurPalSize = 0; // 当前调色板项数（针对于局部调色板）
  151. m_CurDM = 0; // 当前的处置方法
  152. m_CurUserInput = 0; // 当前的用户输入标志
  153. m_CurTColorIndex = -1; // 当前的透明色索引号（-1表示无效）
  154. m_CurDelayTime = 0; // 当前的延迟时间（0表示没有延时）
  155. m_CurSaveMode = 0; // 当前的图像存储模式
  156. m_CurX = m_CurY = 0; // 当前图像在虚拟屏幕中的位置
  157. m_CurWidth = m_CurHeight = 0; // 当前图像的宽度、高度
  159. m_CurImgIndex = 0; // 当前图像的序号（0基）
  160. m_pSubimgHead = NULL; // 子图像链表的头
  161. m_pSubimgTail = NULL; // 子图像链表的尾
  162. }
  164. /////////////////////////////////////////////////////////////////////////////
  165. // The one and only CGifModuleApp object
  167. CGifModuleApp theApp;
  170. // 接口函数声明 — 第一层，唯一与外界联系的接口
  171. int WINAPI AccessGIFModule(INFOSTR *pInfo)
  172. {
  173. // 这个函数可以不作修改的使用，除非你的返回值多于两种。
  175. switch(pInfo->comm)
  176. {
  177. case CMD_GETPROCTYPE: // 获取本模块能处理的图像类型
  178. _fnCMD_GETPROCTYPE(pInfo);
  179. break;
  180. case CMD_GETWRITERS: // 获取本模块的作者列表，多人时用逗号分隔
  181. _fnCMD_GETWRITERS(pInfo);
  182. break;
  183. case CMD_GETWRITERMESS: // 获取作者们的留言
  184. _fnCMD_GETWRITERMESS(pInfo);
  185. break;
  186. case CMD_GETBUILDID: // 获取图像模块内部版本号
  187. _fnCMD_GETBUILDID(pInfo);
  188. break;
  189. case CMD_IS_VALID_FILE: // 判断指定文件是否是有效的GIF文件
  190. _fnCMD_IS_VALID_FILE(pInfo);
  191. break;
  192. case CMD_GET_FILE_INFO: // 获取指定文件的信息
  193. _fnCMD_GET_FILE_INFO(pInfo);
  194. break;
  195. case CMD_LOAD_FROM_FILE: // 从指定图像文件中读取数据
  196. _fnCMD_LOAD_FROM_FILE(pInfo);
  197. break;
  198. case CMD_SAVE_TO_FILE: // 将数据保存到指定文件中
  199. _fnCMD_SAVE_TO_FILE(pInfo);
  200. break;
  201. case CMD_IS_SUPPORT: // 查询某个命令是否被支持
  202. _fnCMD_IS_SUPPORT(pInfo);
  203. break;
  204. case CMD_RESIZE: // 从新获取指定尺寸的图像位数据（只适用于矢量图像）
  205. _fnCMD_RESIZE(pInfo);
  206. break;
  207. default:
  208. pInfo->result = ER_ILLCOMM; // 非法命令
  209. ASSERT(FALSE); // 调用者的程序设计有问题 :-)
  210. break;
  211. }
  213. // 执行命令成功返回1, 失败返回0
  214. return (pInfo->result==ER_SUCCESS)? 1:0;
  215. }
  221. // 命令解释函数 — 第二层解释函数
  222. //********************************************************************//
  224. // 操作命令解释函数---解释：CMD_IS_SUPPORT命令
  225. // 查询某个命令是否被支持
  226. void _fnCMD_IS_SUPPORT(INFOSTR *pInfo)
  227. {
  228. ASSERT(pInfo->result == ER_EMPTY);
  230. switch(pInfo->annexdata.cmAnnData)  
  231. {
  232. case CMD_GETPROCTYPE: // 获取本模块能处理的图像类型
  233. pInfo->result = ER_SUCCESS;
  234. break;
  235. case CMD_GETWRITERS: // 获取本模块的作者列表，多人时用逗号分隔
  236. pInfo->result = ER_SUCCESS;
  237. break;
  238. case CMD_GETWRITERMESS: // 获取作者们的留言
  239. pInfo->result = ER_SUCCESS;
  240. break;
  241. case CMD_GETBUILDID: // 获取图像模块内部版本号
  242. pInfo->result = ER_SUCCESS;
  243. break;
  244. case CMD_IS_VALID_FILE: // 判断指定文件是否是有效的WMF文件
  245. pInfo->result = ER_SUCCESS;
  246. break;
  247. case CMD_GET_FILE_INFO: // 获取指定文件的信息
  248. pInfo->result = ER_SUCCESS;
  249. break;
  250. case CMD_LOAD_FROM_FILE: // 从指定图像文件中读取数据
  251. pInfo->result = ER_SUCCESS;
  252. break;
  253. case CMD_SAVE_TO_FILE: // 将数据保存到指定文件中
  254. pInfo->result = ER_NOTSUPPORT;
  255. break;
  256. case CMD_IS_SUPPORT: // 查询某个命令是否被支持
  257. pInfo->result = ER_SUCCESS;
  258. break;
  259. case CMD_RESIZE: // 获取指定尺寸的图像（只适用于矢量图像）
  260. pInfo->result = ER_NOTSUPPORT;
  261. break;
  262. default:
  263. pInfo->result = ER_NOTSUPPORT;
  264. break;
  265. }
  266. }
  269. // 操作命令解释函数---解释：CMD_GETPROCTYPE命令
  270. // 获取本模块能处理的图像类型，如：BMP，PCX等等
  271. void _fnCMD_GETPROCTYPE(INFOSTR *pInfo)
  272. {
  273. // 这是预定义的函数代码，你可以不必修改的使用。
  275. // 根据接口定义，此时附加数据应被清空为0，所以下此断言
  276. ASSERT(pInfo->annexdata.scAnnData[0] == 0);
  277. ASSERT(pInfo->result == ER_EMPTY);
  278. // 复制能处理的类型字符串
  279. ::CopyMemory((PVOID)pInfo->annexdata.scAnnData, (PVOID)ModuleProcessImgType, 
  280. sizeof(ModuleProcessImgType));
  282. pInfo->result = ER_SUCCESS;
  283. }
  287. // 操作命令解释函数---解释：CMD_GETWRITER命令
  288. // 获取本模块的作者列表，多人时用逗号分隔
  289. void _fnCMD_GETWRITERS(INFOSTR *pInfo)
  290. {
  291. // 这是预定义的函数代码，你可以不必修改的使用。
  293. // 根据接口定义，此时附加数据应被清空为0，所以下此断言
  294. ASSERT(pInfo->annexdata.scAnnData[0] == 0);
  295. ASSERT(pInfo->result == ER_EMPTY);
  296. // 复制开发者名单串
  297. ::CopyMemory((PVOID)pInfo->annexdata.scAnnData, (PVOID)WriterList, 
  298. sizeof(WriterList));
  300. pInfo->result = ER_SUCCESS;
  301. }
  304. // 操作命令解释函数---解释：CMD_GETWRITERMESS命令
  305. // 获取作者们的留言
  306. void _fnCMD_GETWRITERMESS(INFOSTR *pInfo)
  307. {
  308. // 这是预定义的函数代码，你可以不必修改的使用。
  310. // 根据接口定义，此时附加数据应被清空为0，所以下此断言
  311. ASSERT(pInfo->annexdata.scAnnData[0] == 0);
  312. ASSERT(pInfo->result == ER_EMPTY);
  313. // 复制开发者们的留言字符串
  314. ::CopyMemory((PVOID)pInfo->annexdata.scAnnData, (PVOID)WriterMess, 
  315. sizeof(WriterMess));
  317. pInfo->result = ER_SUCCESS;
  318. }
  322. // 操作命令解释函数---解释：CMD_GETBUILDID命令
  323. // 获取图像模块内部版本号
  324. void _fnCMD_GETBUILDID(INFOSTR *pInfo)
  325. {
  326. // 这是预定义的函数代码，你可以不必修改的使用。
  328. // 根据接口定义，此时annexdata.dwAnnData应被设为0，所以下此断言
  329. ASSERT(pInfo->annexdata.dwAnnData == 0);
  330. ASSERT(pInfo->result == ER_EMPTY);
  331. // 填写内部版本号码
  332. pInfo->annexdata.dwAnnData = MODULE_BUILDID;
  334. pInfo->result = ER_SUCCESS;
  335. }
  339. // 操作命令解释函数---解释：CMD_IS_VALID_FILE命令
  340. // 判断指定文件是否是有效的WMF文件
  341. void _fnCMD_IS_VALID_FILE(INFOSTR *pInfo)
  342. {
  343. CFile file;
  344. GIFHEADER gifheader;
  345. DWORD dwSize;
  346. UINT uRet;
  348. // 检验入口参数是否符合接口定义
  349. ASSERT(pInfo->result == ER_EMPTY);
  350. ASSERT(pInfo->annexdata.iAnnData == 0);
  351. ASSERT(::strlen(pInfo->filename));
  352. ASSERT(pInfo->state == PKST_NOTVER);
  354. ASSERT(pInfo);
  356. // 设初值
  357. pInfo->result = ER_SUCCESS;
  358. pInfo->annexdata.iAnnData = 0;
  360. // 先判断指定的文件是否存在
  361. if (!IsFileExist(pInfo->filename))
  362. pInfo->result = ER_COMMINFOERR;
  363. else
  364. {
  365. // 打开指定文件
  366. if (!file.Open(pInfo->filename, CFile::modeRead))
  367. {
  368. pInfo->result = ER_FILERWERR; // 打开文件时出错
  369. return;
  370. }
  372. // 获取文件的长度（以字节为单位）
  373. dwSize = file.GetLength();
  375. // 用长度判断
  376. if (dwSize < sizeof(GIFHEADER))
  377. {
  378. // 这不是一个GIF文件，因为GIF文件的长度起码大于GIF文件头
  379. // 结构的长度
  380. file.Close();
  381. return;
  382. }
  384. // 读取GIF文件信息头结构，并检查它的有效性
  385. file.SeekToBegin();
  386. uRet  = file.Read((LPSTR)&gifheader, sizeof(GIFHEADER));
  387. if (uRet != sizeof(GIFHEADER))
  388. {
  389. // 读文件时出错
  390. pInfo->result = ER_FILERWERR;
  391. file.Close();
  392. return;
  393. }
  395. // 判断文件标志
  396. if ((::memcmp((const void*)(gifheader.Signature), (const void*)GIF87a, sizeof(GIFVERSIZE)) != 0)&&
  397. (::memcmp((const void*)(gifheader.Signature), (const void*)GIF89a, sizeof(GIFVERSIZE)) != 0))
  398. {
  399. file.Close();
  400. return;
  401. }
  403. // 到此，大致可以表明该文件是一个GIF文件，iAnnData变量设为1
  404. pInfo->annexdata.iAnnData = 1;
  405. // 表示通过校验
  406. pInfo->state = PKST_PASSVER;
  408. file.Close();
  409. }
  410. }
  415. // 操作命令解释函数---解释：CMD_GET_FILE_INFO命令
  416. // 获取指定文件的信息
  417. // 注：此时数据包中的imginfo结构并没有真正填写完，图像的类型
  418. //     图像的个数、及图像是否可被编辑等值都是暂设的。
  419. void _fnCMD_GET_FILE_INFO(INFOSTR *pInfo)
  420. {
  421. CFile file;
  422. CFileStatus status;
  423. PBYTE pFileContent;
  424. DWORD dwFileLen, uRet;
  425. GIFHEADER *gifheader;
  427. // 检验入口参数是否符合接口定义
  428. ASSERT(pInfo->result == ER_EMPTY);
  429. ASSERT(::strlen(pInfo->filename));
  430. // 此时，该文件必需是一个已存在的、并且是有效的GIF文件
  431. ASSERT(pInfo->state == PKST_PASSVER);
  432. // 客户模块必需要先将imginfo清空为0
  433. ASSERT(pInfo->imginfo.imgtype == IMT_NULL);
  435. // 打开指定文件
  436. if (!file.Open(pInfo->filename, CFile::modeRead))
  437. {
  438. pInfo->result = ER_FILERWERR;
  439. return;
  440. }
  442. // 获取文件长度
  443. dwFileLen = file.GetLength();
  445. // 分配内存，用于存放所有的GIF数据
  446. pFileContent = (PBYTE)::GlobalAlloc(GPTR, dwFileLen+1);
  447. if (!pFileContent)
  448. {
  449. file.Close();
  450. pInfo->result = ER_MEMORYERR;
  451. return;
  452. }
  454. file.SeekToBegin();
  456. // 读取整个的GIF文件到内存中
  457. uRet = file.ReadHuge((void*)pFileContent, dwFileLen);
  458. if (uRet != dwFileLen)
  459. {
  460. ::GlobalFree(pFileContent);
  461. file.Close();
  462. pInfo->result = ER_FILERWERR;
  463. return;
  464. }
  466. gifheader = (GIFHEADER*)pFileContent;
  468. // 这个文件应该已经被校验过的，也就是说应该是有效的GIF文件
  469. ASSERT(gifheader->Signature[0] == 'G');
  471. // 获取GIF文件中的图像个数
  472. int imgcount = _get_imgcount(pFileContent, dwFileLen);
  474. if (imgcount == 0) // 受损的GIF图像文件
  475. {
  476. ::GlobalFree(pFileContent);
  477. file.Close();
  478. pInfo->result = ER_BADIMAGE;
  479. return;
  480. }
  482. LPIMAGEINFOSTR lpImgInfoStr = &pInfo->imginfo;
  484. // 获取文件的长度、图像的宽度、高度等信息
  486. lpImgInfoStr->imgtype = (imgcount == 1) ? IMT_RESSTATIC:IMT_RESDYN;
  487. lpImgInfoStr->imgformat = IMF_GIF;
  488. lpImgInfoStr->filesize = dwFileLen;
  489. // 以下的宽度、高度是指GIF虚拟屏幕的宽、高
  490. lpImgInfoStr->width = gifheader->ScreenWidth;
  491. lpImgInfoStr->height = gifheader->ScreenHeight;
  492. // 获取位深度值
  493. lpImgInfoStr->bitcount = ((gifheader->GlobalFlagByte&0x70)>>4)+1;
  494. lpImgInfoStr->compression = ICS_GIFLZW;
  495. // 每一图像行所占的字节数（GIF中，此值没有意义，所以设为0）
  496. lpImgInfoStr->linesize = 0;
  497. // 图像的个数（如果是动态GIF，图像个数中将包括背景图像，所以要再加一）
  498. lpImgInfoStr->imgnumbers = (imgcount == 1) ? 1:imgcount+1;
  499. // 表示是否可被编辑（动画GIF将不能被编辑，所以设为1）
  500. lpImgInfoStr->imgchang = (imgcount == 1) ? 0:1;
  502. // 获取文件最后的修改日期（月在高字节，日在低字节）
  503. file.GetStatus(status);
  504. lpImgInfoStr->year = (WORD)status.m_mtime.GetYear();
  505. lpImgInfoStr->monday = (WORD)status.m_mtime.GetMonth();
  506. lpImgInfoStr->monday <<= 8;
  507. lpImgInfoStr->monday |= (WORD)status.m_mtime.GetDay();
  509. // 获取文件最后的修改时间（字序：最高—0, 2—时，1—分，0—秒）
  510. lpImgInfoStr->time = status.m_mtime.GetHour();
  511. lpImgInfoStr->time <<= 8;
  512. lpImgInfoStr->time |= status.m_mtime.GetMinute();
  513. lpImgInfoStr->time <<= 8;
  514. lpImgInfoStr->time |= status.m_mtime.GetSecond();
  515. lpImgInfoStr->time &= 0xffffff;
  517. ::GlobalFree(pFileContent);
  518. file.Close();
  520. // 设置出口数据
  521. pInfo->state = PKST_PASSINFO;
  522. pInfo->result = ER_SUCCESS;
  524. // 恢复初始值
  525. ::ZeroMemory((PVOID)&m_GifInfo, sizeof(GIFINFO));
  527. m_CurPalSize = 0; // 当前调色板项数（针对于局部调色板）
  528. m_CurDM = 0; // 当前的处置方法
  529. m_CurUserInput = 0; // 当前的用户输入标志
  530. m_CurTColorIndex = -1; // 当前的透明色索引号（-1表示无效）
  531. m_CurDelayTime = 0; // 当前的延迟时间（0表示没有延时）
  532. m_CurSaveMode = 0; // 当前的图像存储模式
  533. m_CurX = m_CurY = 0; // 当前图像在虚拟屏幕中的位置
  534. m_CurWidth = m_CurHeight = 0; // 当前图像的宽度、高度
  536. m_CurImgIndex = 0; // 当前图像的序号（0基）
  538. return;
  539. }
  543. // 操作命令解释函数---解释：CMD_LOAD_FROM_FILE命令
  544. // 从指定图像文件中读取数据
  545. void _fnCMD_LOAD_FROM_FILE(INFOSTR *pInfo)
  546. {
  547. // 检验入口参数是否符合接口定义
  548. ASSERT(pInfo->result == ER_EMPTY);
  549. ASSERT(::strlen(pInfo->filename));
  550. // 此时，该文件必需是一个已存在的、有效的GIF文件，并且数据包中
  551. // 含有该文件的信息（imginfo结构中）
  552. ASSERT(pInfo->state == PKST_PASSINFO);
  553. ASSERT(pInfo->imginfo.imgformat == IMF_GIF);
  554. ASSERT(pInfo->pImgInfo == NULL);
  555. // 必需设置标准图像格式信息
  556. ASSERT(pInfo->sDIBInfo.bmi.biSize == sizeof(BITMAPINFOHEADER));
  557. ASSERT(pInfo->pLineAddr != NULL);
  558. ASSERT(pInfo->_pbdata != NULL);
  559. // 必需没有子图像链表
  560. ASSERT(pInfo->psubimg == NULL);
  562. CFile file;
  563. DWORD dwFileLen, uRet;
  564. PBYTE pFileContent;
  566. if (pInfo->fpProgress)
  567. {
  568. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, 6))
  569. { // 如果进度函数返回1，则说明用户想中断操作，返回。
  570. pInfo->result = ER_USERBREAK;
  571. return;
  572. }
  573. }
  575. // 打开指定文件
  576. if (!file.Open(pInfo->filename, CFile::modeRead))
  577. {
  578. pInfo->result = ER_FILERWERR;
  579. return;
  580. }
  582. // 获取文件长度
  583. dwFileLen = file.GetLength();
  585. // 分配内存，用于存放所有的GIF数据
  586. pFileContent = (PBYTE)::GlobalAlloc(GPTR, dwFileLen+1);
  587. if (!pFileContent)
  588. {
  589. file.Close();
  590. pInfo->result = ER_MEMORYERR;
  591. return;
  592. }
  594. file.SeekToBegin();
  596. // 读取整个的GIF文件到内存中
  597. uRet = file.ReadHuge((void*)pFileContent, dwFileLen);
  598. if (uRet != dwFileLen)
  599. {
  600. ::GlobalFree(pFileContent);
  601. file.Close();
  602. pInfo->result = ER_FILERWERR;
  603. return;
  604. }
  606. // 关闭GIF文件
  607. file.Close();
  609. // 读取并转换图像到数据包中
  610. if (LoadGIF(pFileContent, dwFileLen, pInfo) == TRUE)
  611. {
  612. // 成功
  613. pInfo->state = PKST_INFOANDBITS;
  614. pInfo->modify = 0;
  615. pInfo->result = ER_SUCCESS;
  616. }
  618. // 释放内存
  619. ::GlobalFree(pFileContent);
  621. // 恢复初始值
  622. ::ZeroMemory((PVOID)&m_GifInfo, sizeof(GIFINFO));
  624. m_CurPalSize = 0; // 当前调色板项数（针对于局部调色板）
  625. m_CurDM = 0; // 当前的处置方法
  626. m_CurUserInput = 0; // 当前的用户输入标志
  627. m_CurTColorIndex = -1; // 当前的透明色索引号（-1表示无效）
  628. m_CurDelayTime = 0; // 当前的延迟时间（0表示没有延时）
  629. m_CurSaveMode = 0; // 当前的图像存储模式
  630. m_CurX = m_CurY = 0; // 当前图像在虚拟屏幕中的位置
  631. m_CurWidth = m_CurHeight = 0; // 当前图像的宽度、高度
  633. m_CurImgIndex = 0; // 当前图像的序号（0基）
  635. m_pSubimgHead = NULL; // 子图像链表的头
  636. m_pSubimgTail = NULL; // 子图像链表的尾
  638. if (pInfo->fpProgress) // 结束进度条，此调用不再支持用户中断
  639. (*pInfo->fpProgress)(RWPROGRESSSIZE, RWPROGRESSSIZE);
  641. }
  645. // 操作命令解释函数---解释：CMD_SAVE_TO_FILE命令
  646. // 将数据保存到指定文件中
  647. void _fnCMD_SAVE_TO_FILE(INFOSTR *pInfo)
  648. {
  649. // 这个命令不一定要解释，你可以参考本图像格式的具体境况来决定
  650. // 是否解释该命令。
  651. // 如果你想解释该命令，请在下面加入代码，并修改pInfo->result的返回值：
  652. // ----------------------------------------------------------------->
  654. pInfo->result = ER_NOTSUPPORT;
  655. }
  660. // 操作命令解释函数---解释：CMD_RESIZE命令
  661. // 重新获取指定尺寸的图像位数据（只适用于矢量图像）
  662. void _fnCMD_RESIZE(INFOSTR *pInfo)
  663. {
  664. // 这个命令一般的图像读写模块不需要支持，它只适用于矢量图像，
  665. // 比如WMF、EMF之类。
  666. // 如果你想解释该命令，请在下面加入代码，并修改pInfo->result的返回值：
  667. // ----------------------------------------------------------------->
  669. pInfo->result = ER_NOTSUPPORT;
  670. }
  675. /*************************************************************************
  676.  *
  677.  * IsFileExist()
  678.  * 
  679.  * 参数说明：
  680.  *
  681.  * char *lpFileName - 待判断的文件路径和名称（文件名）
  682.  *
  683.  * 返回值：
  684.  *
  685.  * BOOL - 如果指定的文件存在返回TRUE，否则返回FALSE。
  686.  * 
  687.  * 描述：
  688.  *
  689.  * 判断指定的文件是否存在
  690.  * 
  691.  * 该文件必需可以被读和写
  692.  *
  693.  ************************************************************************/
  696. BOOL IsFileExist(char *lpFileName)
  697. {
  698. CFile file;
  699. BOOL bExist = FALSE; // 文件存在是TRUE，不存在是FALSE
  700. CFileException e;
  702. // 确定指定的文件是否存在
  703. if (file.Open(lpFileName, CFile::modeReadWrite|CFile::shareDenyNone, &e))
  704. {
  705. bExist = TRUE;
  706. file.Close();
  707. }
  708. else
  709. {
  710. // 可能有其他程序正在处理此文件
  711. switch(e.m_cause)
  712. {
  713. case CFileException::tooManyOpenFiles:
  714. case CFileException::accessDenied:
  715. case CFileException::sharingViolation:
  716. case CFileException::lockViolation:
  717. return TRUE;
  718. case CFileException::fileNotFound:
  719. case CFileException::badPath:
  720. case CFileException::invalidFile:
  721. case CFileException::hardIO:
  722. default:
  723. return FALSE;
  724. }
  725. }
  727. return bExist;
  728. }
  732. // 返回TRUE表示读取成功，FALSE表示失败，同时数据包置错误信息
  733. BOOL LoadGIF(PBYTE pFileContent, DWORD filesize, LPINFOSTR pInfo)
  734. {
  735. //获取GIF文件的相关信息
  736. UINT HeaderSize = AnalizeFileHeader(pFileContent, filesize);
  737. if (HeaderSize == 0)
  738. {
  739. // 表明该文件是一个受损的文件
  740. pInfo->result = ER_BADIMAGE;
  741. return FALSE;
  742. }
  744. // 设置背景图像
  745. RGBQUAD * pBKColor = (RGBQUAD*)&(m_GlobalPal[m_GifInfo.bkindex]);
  747. int i,j;
  748. switch(_get_desformat(pInfo))
  749. {
  750. case DF_16_555: // 16位555格式（也就是15位图像）
  751. {
  752. WORD bkc555 = _cnv_rgb_to_555(pBKColor->rgbRed, pBKColor->rgbGreen, 
  753. pBKColor->rgbBlue);
  754. WORD *pPix555;
  755. for (i=0;i<(int)pInfo->imginfo.height;i++)
  756. {
  757. pPix555 = (WORD*)(pInfo->pLineAddr[i]);
  758. for(j=0;j<(int)pInfo->imginfo.width;j++)
  759. *pPix555++ = bkc555;
  760. }
  761. }
  762. break;
  763. case DF_16_565: // 16位565格式
  764. {
  765. WORD bkc565 = _cnv_rgb_to_565(pBKColor->rgbRed, pBKColor->rgbGreen, 
  766. pBKColor->rgbBlue);
  767. WORD *pPix565;
  768. for (i=0;i<(int)pInfo->imginfo.height;i++)
  769. {
  770. pPix565 = (WORD*)(pInfo->pLineAddr[i]);
  771. for(j=0;j<(int)pInfo->imginfo.width;j++)
  772. *pPix565++ = bkc565;
  773. }
  774. }
  775. break;
  776. case DF_24: // 24位格式
  777. {
  778. PBYTE pPix24;
  779. for (i=0;i<(int)pInfo->imginfo.height;i++)
  780. {
  781. pPix24 = (PBYTE)(pInfo->pLineAddr[i]);
  782. for(j=0;j<(int)pInfo->imginfo.width;j++)
  783. {
  784. *pPix24++ = pBKColor->rgbBlue;
  785. *pPix24++ = pBKColor->rgbGreen;
  786. *pPix24++ = pBKColor->rgbRed;
  787. }
  788. }
  789. }
  790. break;
  791. case DF_32: // 32位格式
  792. {
  793. DWORD bkc32 = _cnv_rgb_to_888(pBKColor->rgbRed, pBKColor->rgbGreen, 
  794. pBKColor->rgbBlue);
  795. DWORD *pPix32;
  796. for (i=0;i<(int)pInfo->imginfo.height;i++)
  797. {
  798. pPix32 = (DWORD*)(pInfo->pLineAddr[i]);
  799. for(j=0;j<(int)pInfo->imginfo.width;j++)
  800. *pPix32++ = bkc32;
  801. }
  802. }
  803. break;
  804. }
  806. m_CurTColorIndex = -1;
  807. m_CurDelayTime = 0;
  809. // 跨过头结构
  810. PBYTE p = pFileContent+HeaderSize;
  812. UINT  Offset;
  814. while (1)
  815. {
  816. if (p[0] == 0x21 && p[1] == 0xf9 && p[2] == 0x04)
  817. {// 图形扩展块
  818. Offset = GetGrphContent(p);
  819. p += Offset;
  820. }
  821. else if (p[0] == 0x21 && p[1] == 0x01 && p[2] == 0x0c)
  822. {// 文本扩展块
  823. Offset = ShowText(p);
  824. p += Offset;
  825. }
  826. else if (p[0] == 0x21 && p[1] == 0xff && p[2] == 0x0b)
  827. {// 应用程序扩展块
  828. Offset = GetAppContent(p);
  829. p += Offset;
  830. }
  831. else if (p[0] == 0x21 && p[1] == 0xfe)
  832. {// 注释扩展块
  833.    Offset = GetNoteContent(p);
  834.    p += Offset;
  835. }
  836. else if (p[0] == 0x2c)
  837. {// 图像描述符＋[局部调色板]＋图像数据块
  838.    Offset = GetImage(p, pInfo);
  839.    p += Offset;
  840. }
  841. else break;
  843. if (Offset == 0)
  844. {
  845. // 内存不足，失败
  846. _clear_list();
  847. pInfo->result = ER_MEMORYERR;
  848. return FALSE;
  849. }
  851. if (((DWORD)p-(DWORD)pFileContent) > filesize)
  852. {
  853. // 表明该文件是一个受损的文件
  854. _clear_list();
  855. pInfo->result = ER_BADIMAGE;
  856. return FALSE;
  857. }
  858. }
  860. // 子图像链表指针
  861. pInfo->psubimg = m_pSubimgHead;
  863. return TRUE;
  864. }
  867. /***************************************************************************
  868. * AnalizeFileHeader - 获得GIF文件信息
  869. *
  870. * Parameter: PBYTE - 完整的GIF文件数据首指针
  871. *              DWORD - GIF文件的长度
  872. *
  873. * Result   : UINT  - GIF文件头结构尺寸（包括虚拟屏幕结构及全局调色板）
  874. *    如果返回0，则说明GIF文件是一个受损的文件
  875. ***************************************************************************/
  876. UINT AnalizeFileHeader(PBYTE pFileContent, DWORD filesize)
  877. {
  878. ASSERT(filesize > sizeof(GIFHEADER));
  880. GIFHEADER gifHeader; //文件头
  881. UINT uRet = sizeof(GIFHEADER);
  883. memcpy(&gifHeader,pFileContent,sizeof(GIFHEADER));
  885. // 取得图像（逻辑屏幕）的宽度、高度
  886. m_GifInfo.Width  = gifHeader.ScreenWidth ;
  887. m_GifInfo.Height = gifHeader.ScreenHeight ;
  889. // 获取图像位深度
  890. m_GifInfo.BitCount  = ((gifHeader.GlobalFlagByte&0x70)>>4)+1;
  892. // 获取GIF背景色索引
  893. m_GifInfo.bkindex = gifHeader.BackGroundColor;
  895. // 单个压缩数据初始位数
  896. m_GifInfo.InitPixelBits = (gifHeader.GlobalFlagByte&0x7)+2;
  898. // 获得图像的颜色个数
  899. m_GifInfo.ColorNum = 1<<((gifHeader.GlobalFlagByte&0x7)+1);
  901. if (gifHeader.GlobalFlagByte&0x80)
  902. { 
  903. // 有全局调色板
  904. LPGIFRGB pRGB = (LPGIFRGB)(pFileContent+sizeof(GIFHEADER));
  906. for (int j=0;j<m_GifInfo.ColorNum;j++)
  907. {
  908. m_GlobalPal[j].rgbRed       = pRGB[j].bRed;
  909. m_GlobalPal[j].rgbGreen     = pRGB[j].bGreen;
  910. m_GlobalPal[j].rgbBlue      = pRGB[j].bBlue;
  911. m_GlobalPal[j].rgbReserved  = 0;
  912. }
  913. // 跨过全局调色板
  914. uRet += m_GifInfo.ColorNum*sizeof(GIFRGB);
  916. if (uRet >= filesize)
  917. uRet = 0; // 说明文件太小，可能是一个受损的GIF文件
  918. }
  920. return uRet;
  921. }
  924. // 处理图形扩展块
  925. UINT GetGrphContent(PBYTE pGrCtrl)
  926. {
  927. ASSERT(pGrCtrl);
  929. GRAPHCTRL GraphCtrl;
  930. memcpy(&GraphCtrl,pGrCtrl,sizeof(GRAPHCTRL));
  932. BYTE Flag = GraphCtrl.PackedField; // 包装域
  933. m_CurDM = (int)((BYTE)(Flag&0x1c)>>2); // 处置方式
  934. m_CurUserInput = (int)((BYTE)(Flag&0x2)>>1); // 用户输入标志
  935. m_CurDelayTime = GraphCtrl.DelayTime; // 延迟时间
  937. if (Flag&1) // 判断是否有透明色
  938.    m_CurTColorIndex = GraphCtrl.TranColorIndex;
  939. else
  940. m_CurTColorIndex = -1;
  942. return sizeof(GRAPHCTRL);
  943. }
  946. // 处理文本扩展块
  947. UINT ShowText(PBYTE pText)
  948. {
  949. ASSERT(pText);
  951. TEXTCTRL TextCtrl;
  952. memcpy(&TextCtrl,pText,sizeof(TEXTCTRL));
  953. return sizeof(TEXTCTRL)+TextCtrl.Data[0]-256+1;
  954. }
  957. // 处理应用程序扩展块
  958. UINT GetAppContent(PBYTE pApp)
  959. {
  960. ASSERT(pApp);
  962. APPCTRL AppCtrl;
  963. memcpy(&AppCtrl,pApp,sizeof(APPCTRL));
  964. return sizeof(APPCTRL)+AppCtrl.Data[0]-256+1;
  965. }
  968. // 处理注释扩展块
  969. UINT GetNoteContent(PBYTE pNote)
  970. {
  971. ASSERT(pNote);
  973. NOTEHCTRL NoteCtrl;
  974. memcpy(&NoteCtrl,pNote,sizeof(NOTEHCTRL));
  975. return sizeof(NOTEHCTRL)+NoteCtrl.Data[0]-256+1;
  976. }
  979. // 处理图像数据区
  980. UINT GetImage(PBYTE pData, LPINFOSTR pInfo)
  981. {
  982. ASSERT(pData);
  984. IMAGEDATAINFO ImageData;
  985. // 提取图像描述
  986. memcpy(&ImageData,pData,sizeof(IMAGEDATAINFO));
  988. PBYTE p = pData+sizeof(IMAGEDATAINFO);
  990. UINT PalSize;
  992. m_CurX = ImageData.ImageLeft;
  993. m_CurY = ImageData.ImageTop ;
  994. m_CurWidth  = ImageData.ImageWidth ;
  995. m_CurHeight = ImageData.ImageHeight;
  997. // 判断是否有局部调色板
  998. if (ImageData.LocalFlagByte&0x80)
  999. { 
  1000. LPGIFRGB pRGB = (LPGIFRGB)p;
  1001. // 计算局部调色版的项数
  1002. m_CurPalSize  = 1<<((ImageData.LocalFlagByte&0x7)+1);
  1004. // 有关文档对这个值描述的不是很清楚，为保险起见作了
  1005. // 如下判断。
  1006. if ((m_CurPalSize <= 0)||(m_CurPalSize > 256))
  1007. m_CurPalSize = m_GifInfo.ColorNum;
  1009. for (int j=0;j<m_CurPalSize;j++)
  1010. {
  1011. m_CurRgbQuad[j].rgbRed       = pRGB[j].bRed;
  1012. m_CurRgbQuad[j].rgbGreen     = pRGB[j].bGreen;
  1013. m_CurRgbQuad[j].rgbBlue      = pRGB[j].bBlue;
  1014. m_CurRgbQuad[j].rgbReserved  = 0;
  1015. }
  1016. // 计算调色板尺寸（字节数）
  1017. PalSize = m_CurPalSize*sizeof(GIFRGB);
  1018. // 跨过局部调色板
  1019. p += PalSize;
  1020. }
  1021. else
  1022. {
  1023. // 如果没有局部调色板，用全局调色板数据替代
  1024. m_CurPalSize = m_GifInfo.ColorNum;
  1025. memcpy((void*)m_CurRgbQuad, (void*)m_GlobalPal, m_CurPalSize*sizeof(RGBQUAD));
  1026. PalSize = 0;
  1027. }
  1029. // 设置图像存储模式标志
  1030. if (ImageData.LocalFlagByte&0x40)
  1031. m_CurSaveMode = 1; // 交叉存储
  1032. else
  1033. m_CurSaveMode = 0; // 顺序存储
  1036. UINT InitBits = *p++;//跳过第一字节，进入真正的段落
  1038. UINT offset; // 数据区在文件中的尺寸（将包括GIF附加的描述符）
  1040. // 获取当前数据区的尺寸（纯数据尺寸）
  1041. UINT dataCount = GetCodeCountOnChar(p, offset);
  1043. // 获取当前数据区内容
  1044. PBYTE pCodeData = GetCodeDataOnChar(p, dataCount);
  1045. if (!pCodeData)
  1046. return 0;
  1048. // 提取真实数据,所有数据存为字符大小
  1049. PBYTE pTrueCodeData = GetCodeDataOnBits(pCodeData, 
  1050. m_GifInfo.InitPixelBits, dataCount);
  1051. if (!pTrueCodeData)
  1052. {
  1053. ::GlobalFree(pCodeData);
  1054. return 0;
  1055. }
  1057. ::GlobalFree(pCodeData);
  1059. // 将GIF图像数据保存（并转化）到子图像链表中
  1060. BOOL bRet;
  1062. if (pInfo->imginfo.imgnumbers > 1) // 多帧GIF图像
  1063. bRet = ConvertToBmpImage(pTrueCodeData, pInfo);
  1064. else // 单帧GIF图像
  1065. bRet = ConvertToBackgroup(pTrueCodeData, pInfo);
  1067. ::GlobalFree(pTrueCodeData);
  1069. if (bRet == FALSE)
  1070. return 0;
  1071. else
  1072. return sizeof(IMAGEDATAINFO) + offset + PalSize;
  1073. }
  1076. // 计算图像位数据的尺寸
  1077. UINT GetCodeCountOnChar (PBYTE CodeDataStr,UINT &AllDataLen)
  1078. {
  1079. UINT dataCount = 0;
  1080. BYTE dataLen;
  1081. PBYTE p1 = CodeDataStr;
  1082. AllDataLen = 0;
  1083. while(1)
  1084. {
  1085. dataLen = *p1++; // 提取长度描述字节值，并后移指针
  1086. p1 += dataLen;
  1087. dataCount += dataLen;
  1088. AllDataLen += (dataLen+1); // 数据子块长度加长度描述字节
  1089. if (dataLen == 0x00) break;
  1090. }
  1091. AllDataLen ++; // 跨过LZW初始位值的一个字节
  1093. return dataCount;
  1094. }
  1097. // 将GIF中的纯LZW图像数据提取到新的内存块中
  1098. PBYTE GetCodeDataOnChar(PBYTE CodeDataStr, UINT dataCount)
  1099. {
  1100. ASSERT(CodeDataStr);
  1102. PBYTE pData = (PBYTE)::GlobalAlloc(GPTR, dataCount+1);
  1103. if (!pData)
  1104. return NULL;
  1106. PBYTE p2 = pData;
  1107. PBYTE p1 = CodeDataStr;
  1108. BYTE  dataLen;
  1110. while (1)
  1111. {
  1112. dataLen = *p1++;
  1113. if (dataLen == 0x00) 
  1114. break;
  1115. memcpy(p2,p1,dataLen);
  1116. p1 += dataLen;
  1117. p2 += dataLen;
  1118. }
  1120. return pData;
  1121. }
  1124. // 将指定的LZW数据解压为位图数据
  1125. PBYTE  GetCodeDataOnBits (PBYTE CodeDataStr ,UINT InitLen ,UINT &CodeDataLen)
  1126. {
  1127. ASSERT(CodeDataStr);
  1129. PBYTE pData = (PBYTE)::GlobalAlloc(GPTR ,m_CurWidth*m_CurHeight*2);
  1130. if (!pData)
  1131. return NULL;
  1133. PBYTE p = CodeDataStr;
  1134. PBYTE pTrueData = pData;
  1136. int i = 0;
  1137. UINT BitsCount = 0;
  1138. WORD TCode,s = m_GifInfo.ColorNum+2;//起始的代码值
  1139. UINT TableLen,iLen = InitLen;
  1140. UINT Pos,index,j = 0;
  1141. UINT SrcCodeLEN = CodeDataLen;
  1143. while (1)
  1144. {
  1145. TCode = GetOneCode(p, CodeDataLen,BitsCount/8, BitsCount%8, iLen);
  1146. BitsCount += iLen;
  1148. if (TCode < m_GifInfo.ColorNum)
  1149. {
  1150. LZWTable[j].Header = TCode;
  1151. LZWTable[j].Code   = s ++;
  1152. if (j != 0)
  1153. {
  1154. LZWTable[j - 1].Tail = TCode;
  1155. }
  1156. j++;
  1157. }
  1158. else if (TCode > m_GifInfo.ColorNum + 1) // 代码
  1159. {
  1160. if (j == 0) continue;
  1161. LZWTable[j].Header = TCode;
  1162. LZWTable[j].Code   = s ++;
  1163. ASSERT( LZWTable[j].Header < LZWTable[j].Code);
  1164. index = j - 1;
  1165. Pos = j;
  1166. while (1)
  1167. {
  1168. Pos = LZWTable[Pos].Header - (m_GifInfo.ColorNum + 2) ;
  1169. if (LZWTable[Pos].Header < m_GifInfo.ColorNum) 
  1170. break;
  1171. }
  1172. LZWTable[index].Tail  = LZWTable[Pos].Header;
  1173. j++;
  1174. }
  1175. else if (TCode == m_GifInfo.ColorNum) // 清除码
  1176. {
  1177. iLen = InitLen;
  1178. TableLen = j;
  1179. j = 0;
  1180. if (GetPartImageDataFromTable(pData,LZWTable,TableLen) == FALSE)
  1181. {
  1182. ::GlobalFree(pTrueData);
  1183. return NULL;
  1184. }
  1185. //pData+=TableLen;
  1186. s = m_GifInfo.ColorNum + 2 ;
  1187. }
  1188. else if (TCode == m_GifInfo.ColorNum + 1) // 结束码
  1189. {
  1190. //end build table
  1191. iLen = InitLen;
  1192. TableLen = j;
  1193. if (GetPartImageDataFromTable(pData,LZWTable,TableLen) == FALSE)
  1194. {
  1195. ::GlobalFree(pTrueData);
  1196. return NULL;
  1197. }
  1198. //pData+=TableLen;
  1199. s = m_GifInfo.ColorNum + 2;
  1200. break;
  1201. }
  1203. if (s == 3)
  1204. iLen = 2;
  1205. else if (s == 5)
  1206. iLen = 3;
  1207. else if (s == 9)
  1208. iLen = 4;
  1209. else if (s == 17)
  1210. iLen = 5;
  1211. else if (s == 33)
  1212. iLen = 6;
  1213. else if (s == 65)
  1214. iLen = 7;
  1215. else if (s == 129)
  1216. iLen  = 8;
  1217. else if (s == 257)
  1218. iLen  = 9;
  1219. else if ( s == 513 ) 
  1220. iLen = 10;
  1221. else if (s == 1025 ) 
  1222. iLen = 11;
  1223. else if (s == 2049 ) 
  1224. iLen = 12;
  1226. if (BitsCount/8 > SrcCodeLEN)
  1227. {
  1228. iLen = InitLen;
  1229. TableLen = j;
  1230. if (GetPartImageDataFromTable(pData,LZWTable,TableLen) == FALSE)
  1231. {
  1232. ::GlobalFree(pTrueData);
  1233. return NULL;
  1234. }
  1235. //pData+=TableLen;
  1236. s = m_GifInfo.ColorNum + 2;
  1237. break;
  1238. }
  1240. }
  1241. CodeDataLen = BitsCount/8;
  1243. return pTrueData;
  1244. }
  1247. WORD GetOneCode(PBYTE CodeStr ,UINT CodeStrLen, UINT OffsetChar, 
  1248. UINT OffsetBits, UINT Length)
  1249. {
  1250. ASSERT (Length <= 12);
  1252. PBYTE pValue;
  1253. PBYTE lp = CodeStr;
  1255. DWORD value = 0;
  1256. pValue = (PBYTE)&value;
  1258. pValue[0] = lp[OffsetChar+0];
  1260. if (OffsetChar + 1 < CodeStrLen)
  1261. pValue[1] = lp[OffsetChar+1];
  1262. if (OffsetChar + 2 < CodeStrLen)
  1263. pValue[2] = lp[OffsetChar+2];
  1264. if (OffsetChar + 3 < CodeStrLen)
  1265. pValue[3] = lp[OffsetChar+3];
  1267. value = value >> OffsetBits;
  1268. value = value << (32 - Length);
  1269. value = value >> (32 - Length);
  1271. return (WORD)value;
  1272. }
  1275. //
  1276. BOOL GetPartImageDataFromTable(PBYTE &pImage, LZWTABLE *Table, UINT TableLen)
  1277. {
  1278. UINT i;
  1279. PBYTE p = pImage;
  1281. WORD *TailStack = (WORD*)::GlobalAlloc(GPTR, LZWTABLESIZE*sizeof(WORD));
  1282. if (!TailStack)
  1283. return FALSE;
  1285. int j;
  1286. int sp;
  1288. for (i = 0 ; i < TableLen; i++)
  1289. {
  1290. if (Table[i].Header < m_GifInfo.ColorNum)
  1291. {
  1292. *p++ = (BYTE)Table[i].Header ;
  1293. }
  1294. else
  1295. {
  1296. sp = 0;
  1297. j = Table[i].Header - (m_GifInfo.ColorNum + 2);
  1298. while (Table[j].Header > m_GifInfo.ColorNum + 1)
  1299. {
  1300. TailStack[sp++] = Table[j].Tail ;
  1301. j = Table[j].Header;
  1302. j -= (m_GifInfo.ColorNum + 2);
  1303. ASSERT(sp < LZWTABLESIZE);
  1304. }
  1305. *p++ = (BYTE)Table[j].Header;
  1306. *p++ = (BYTE)Table[j].Tail;
  1307. sp --;
  1308. while (sp >= 0)
  1309. {
  1310. *p++ = (BYTE)TailStack[sp--];
  1311. }
  1312. }
  1313. }
  1314. int len = p - pImage;
  1315. pImage = p;
  1317. ::GlobalFree(TailStack);
  1319. return TRUE;
  1320. }
  1323. // 将GIF图像保存到数据包背景图像中（只针对单帧GIF图像）
  1324. BOOL ConvertToBackgroup(PBYTE SrcData,LPINFOSTR lpInfo)
  1325. {
  1326. ASSERT(SrcData);
  1327. ASSERT(lpInfo->imginfo.imgnumbers == 1);
  1329. PBYTE p2,pTmp;
  1330. PBYTE pSrcData = SrcData;
  1332. int i,j,k,Step,index;
  1334. if (m_CurSaveMode )//交叉存储
  1335. {
  1336. pTmp = p2 = (PBYTE)::GlobalAlloc(GPTR, m_CurWidth*m_CurHeight);
  1337. if (!pTmp)
  1338. return FALSE;
  1340. k = 0; Step = 8;
  1341. for (j = 0; j < m_CurHeight  ; j ++)
  1342. {
  1343. memcpy(pTmp+k*m_CurWidth,pSrcData+j*m_CurWidth,m_CurWidth);
  1344. k += Step;
  1345. if (k >= m_CurHeight) break;
  1346. }
  1347. j++;//每行中存了一个越界值
  1348. k = 4; Step = 8;
  1349. for (; j < m_CurHeight  ; j ++)
  1350. {
  1351. memcpy(pTmp+k*m_CurWidth,pSrcData+j*m_CurWidth,m_CurWidth);
  1352. k += Step;
  1353. if (k >= m_CurHeight) break;
  1354. }
  1355. j++;
  1356. k = 2; Step = 4;
  1357. for (; j < m_CurHeight  ; j ++)
  1358. {
  1359. memcpy(pTmp+k*m_CurWidth,pSrcData+j*m_CurWidth,m_CurWidth);
  1360. k += Step;
  1361. if (k >= m_CurHeight) break;
  1362. }
  1363. j++;
  1364. k = 1; Step = 2;
  1365. for (; j < m_CurHeight  ; j ++)
  1366. {
  1367. memcpy(pTmp+k*m_CurWidth,pSrcData+j*m_CurWidth,m_GifInfo.Width);
  1368. k += Step;
  1369. if (k >= m_CurHeight) break;
  1370. }
  1371. pSrcData = p2;
  1372. p2 = NULL;
  1373. }
  1375. // 转换图像到数据包指定格式
  1376. switch(_get_desformat(lpInfo))
  1377. {
  1378. case DF_16_555: // 16位555格式（也就是15位图像）
  1379. {
  1380. for (j=0;j<m_CurHeight;j++)
  1381. {
  1382. WORD *pImg555 = (WORD*)(lpInfo->pLineAddr[j]);
  1383. for (i=0;i<m_CurWidth;i++)
  1384. {
  1385. index = pSrcData[j*m_CurWidth+i];
  1386. WORD bkc555 = _cnv_rgb_to_555(m_CurRgbQuad[index].rgbRed, 
  1387.   m_CurRgbQuad[index].rgbGreen, 
  1388.   m_CurRgbQuad[index].rgbBlue);
  1389. *pImg555++ = bkc555;
  1390. }
  1391. }
  1392. }
  1393. break;
  1394. case DF_16_565: // 16位565格式
  1395. {
  1396. for (j=0;j<m_CurHeight;j++)
  1397. {
  1398. WORD *pImg565 = (WORD*)(lpInfo->pLineAddr[j]);
  1399. for (i=0;i<m_CurWidth;i++)
  1400. {
  1401. index = pSrcData[j*m_CurWidth+i];
  1402. WORD bkc565 = _cnv_rgb_to_565(m_CurRgbQuad[index].rgbRed, 
  1403.   m_CurRgbQuad[index].rgbGreen, 
  1404.   m_CurRgbQuad[index].rgbBlue);
  1405. *pImg565++ = bkc565;
  1406. }
  1407. }
  1408. }
  1409. break;
  1410. case DF_24: // 24位格式
  1411. {
  1412. for (j=0;j<m_CurHeight;j++)
  1413. {
  1414. PBYTE pImg24 = (PBYTE)(lpInfo->pLineAddr[j]);
  1415. for (i=0;i<m_CurWidth;i++)
  1416. {
  1417. index = pSrcData[j*m_CurWidth+i];
  1418. *pImg24++ = m_CurRgbQuad[index].rgbBlue;
  1419. *pImg24++ = m_CurRgbQuad[index].rgbGreen;
  1420. *pImg24++ = m_CurRgbQuad[index].rgbRed;
  1421. }
  1422. }
  1423. }
  1424. break;
  1425. case DF_32: // 32位格式
  1426. {
  1427. for (j=0;j<m_CurHeight;j++)
  1428. {
  1429. DWORD *pImg32 = (DWORD*)(lpInfo->pLineAddr[j]);
  1430. for (i=0;i<m_CurWidth;i++)
  1431. {
  1432. index = pSrcData[j*m_CurWidth+i];
  1433. DWORD bkc32 = _cnv_rgb_to_888( m_CurRgbQuad[index].rgbRed, 
  1434.   m_CurRgbQuad[index].rgbGreen, 
  1435.   m_CurRgbQuad[index].rgbBlue);
  1436. *pImg32++ = bkc32;
  1437. }
  1438. }
  1439. }
  1440. break;
  1441. default:
  1442. ASSERT(FALSE);
  1443. break;
  1444. }
  1446. if (m_CurSaveMode) //交叉存储
  1447. GlobalFree(pSrcData);
  1449. return TRUE;
  1450. }
  1452. // 将某一子图像保存到子图像链表中
  1453. BOOL ConvertToBmpImage(PBYTE SrcData, LPINFOSTR lpInfo)
  1454. {
  1455. ASSERT(SrcData);
  1457. PBYTE p2,pTmp;
  1458. PBYTE pSrcData = SrcData;
  1460. int i,j,k,Step,index;
  1462. if (m_CurSaveMode )//交叉存储
  1463. {
  1464. pTmp = p2 = (PBYTE)::GlobalAlloc(GPTR, m_CurWidth*m_CurHeight);
  1465. if (!pTmp)
  1466. return FALSE;
  1468. k = 0; Step = 8;
  1469. for (j = 0; j < m_CurHeight  ; j ++)
  1470. {
  1471. memcpy(pTmp+k*m_CurWidth,pSrcData+j*m_CurWidth,m_CurWidth);
  1472. k += Step;
  1473. if (k >= m_CurHeight) break;
  1474. }
  1475. j++;//每行中存了一个越界值
  1476. k = 4; Step = 8;
  1477. for (; j < m_CurHeight  ; j ++)
  1478. {
  1479. memcpy(pTmp+k*m_CurWidth,pSrcData+j*m_CurWidth,m_CurWidth);
  1480. k += Step;
  1481. if (k >= m_CurHeight) break;
  1482. }
  1483. j++;
  1484. k = 2; Step = 4;
  1485. for (; j < m_CurHeight  ; j ++)
  1486. {
  1487. memcpy(pTmp+k*m_CurWidth,pSrcData+j*m_CurWidth,m_CurWidth);
  1488. k += Step;
  1489. if (k >= m_CurHeight) break;
  1490. }
  1491. j++;
  1492. k = 1; Step = 2;
  1493. for (; j < m_CurHeight  ; j ++)
  1494. {
  1495. memcpy(pTmp+k*m_CurWidth,pSrcData+j*m_CurWidth,m_GifInfo.Width);
  1496. k += Step;
  1497. if (k >= m_CurHeight) break;
  1498. }
  1499. pSrcData = p2;
  1500. p2 = NULL;
  1501. }
  1503. LPSUBIMGBLOCK pSubImage = (LPSUBIMGBLOCK)::GlobalAlloc(GPTR, sizeof(SUBIMGBLOCK));
  1504. if (!pSubImage)
  1505. {
  1506. if (m_CurSaveMode )//交叉存储
  1507. ::GlobalFree(pSrcData);
  1508. return FALSE;
  1509. }
  1511. pSubImage->parents = lpInfo;// 第一桢图像数据的结构地址（所属数据包结构的地址）
  1512. pSubImage->prev = NULL; // 前一桢图像数据的结构地址
  1513. pSubImage->next = NULL; // 后一桢图像数据的结构地址（NULL表示这是最后一副图像）
  1515. DWORD desize = 0; // 子图像BMP格式的尺寸
  1516. DWORD scanlinesize = 0; // 子图像扫描行尺寸
  1518. // 获取数据包标准图像格式之子图像尺寸
  1519. switch(_get_desformat(lpInfo))
  1520. {
  1521. case DF_16_555: // 16位555格式（也就是15位图像）
  1522. case DF_16_565: // 16位565格式
  1523. scanlinesize = WIDTHBYTES(m_CurWidth*16);
  1524. break;
  1525. case DF_24: // 24位格式
  1526. scanlinesize = WIDTHBYTES(m_CurWidth*24);
  1527. case DF_32: // 32位格式
  1528. scanlinesize = m_CurWidth*4;
  1529. break;
  1530. default:
  1531. ASSERT(FALSE);
  1532. if (m_CurSaveMode )//交叉存储
  1533. ::GlobalFree(pSrcData);
  1534. return FALSE;
  1535. }
  1537. desize = scanlinesize*m_CurHeight;
  1539. ASSERT(desize); // 宽度或高度不能是0
  1541. // 分配子图像位数据缓冲区
  1542. pSubImage->pLineAddr = (DWORD**)::GlobalAlloc(GPTR, m_CurHeight*sizeof(DWORD*));
  1543. pSubImage->_pbdata   = (PBYTE)::GlobalAlloc(GPTR, desize);
  1544. if ((pSubImage->pLineAddr == NULL)||(pSubImage->_pbdata == NULL))
  1545. {
  1546. if (m_CurSaveMode) ::GlobalFree(pSrcData);
  1547. if (pSubImage->_pbdata) ::GlobalFree(pSubImage->_pbdata);
  1548. if (pSubImage->pLineAddr) ::GlobalFree(pSubImage->pLineAddr);
  1549. return FALSE;
  1550. }
  1552. // 初始化行首地址数组（倒向DIB格式）
  1553. for (int y=0;y<m_CurHeight;y++)
  1554. {
  1555. pSubImage->pLineAddr[y] = 
  1556. (DWORD*)(pSubImage->_pbdata+((m_CurHeight-y-1)*scanlinesize));
  1557. }
  1559. pSubImage->number = m_CurImgIndex++; // 子图像块的序列号
  1560. pSubImage->left = m_CurX; // 子图像块的显示位置（左上角）
  1561. pSubImage->top  = m_CurY;
  1562. pSubImage->width = m_CurWidth; // 子图像块的图像宽度及高度
  1563. pSubImage->height = m_CurHeight;
  1564. pSubImage->dowith = m_CurDM; // 处置方法（针对于动画GIF）
  1565. pSubImage->userinput = m_CurUserInput; // 用户输入（针对于动画GIF）
  1567. if (m_CurTColorIndex != -1) // 透明色分量值（-1表示无效）
  1568. {
  1569. pSubImage->colorkey = RGB(m_CurRgbQuad[m_CurTColorIndex].rgbRed, 
  1570. m_CurRgbQuad[m_CurTColorIndex].rgbGreen, 
  1571. m_CurRgbQuad[m_CurTColorIndex].rgbBlue);
  1572. }
  1573. else
  1574. pSubImage->colorkey = (COLORREF)((int)(-1));
  1576. pSubImage->time = (int)m_CurDelayTime; // 显示的延迟时间
  1578. // 将子图像块插入链表
  1579. if (m_pSubimgTail == NULL) // 当前是空链表
  1580. {
  1581. m_pSubimgHead = pSubImage;
  1582. m_pSubimgTail = pSubImage;
  1583. }
  1584. else
  1585. {
  1586. ASSERT(m_pSubimgHead->prev == NULL); // 检察链表的有效性
  1587. ASSERT(m_pSubimgTail->next == NULL);
  1588. m_pSubimgTail->next = pSubImage;
  1589. pSubImage->prev = m_pSubimgTail;
  1590. m_pSubimgTail = pSubImage;
  1591. }
  1593. // 转换图像到数据包指定格式
  1594. switch(_get_desformat(lpInfo))
  1595. {
  1596. case DF_16_555: // 16位555格式（也就是15位图像）
  1597. {
  1598. for (j=0;j<m_CurHeight;j++)
  1599. {
  1600. WORD *pImg555 = (WORD*)(pSubImage->pLineAddr[j]);
  1601. for (i=0;i<m_CurWidth;i++)
  1602. {
  1603. index = pSrcData[j*m_CurWidth+i];
  1604. WORD bkc555 = _cnv_rgb_to_555(m_CurRgbQuad[index].rgbRed, 
  1605.   m_CurRgbQuad[index].rgbGreen, 
  1606.   m_CurRgbQuad[index].rgbBlue);
  1607. *pImg555++ = bkc555;
  1608. }
  1609. }
  1610. }
  1611. break;
  1612. case DF_16_565: // 16位565格式
  1613. {
  1614. for (j=0;j<m_CurHeight;j++)
  1615. {
  1616. WORD *pImg565 = (WORD*)(pSubImage->pLineAddr[j]);
  1617. for (i=0;i<m_CurWidth;i++)
  1618. {
  1619. index = pSrcData[j*m_CurWidth+i];
  1620. WORD bkc565 = _cnv_rgb_to_565(m_CurRgbQuad[index].rgbRed, 
  1621.   m_CurRgbQuad[index].rgbGreen, 
  1622.   m_CurRgbQuad[index].rgbBlue);
  1623. *pImg565++ = bkc565;
  1624. }
  1625. }
  1626. }
  1627. break;
  1628. case DF_24: // 24位格式
  1629. {
  1630. for (j=0;j<m_CurHeight;j++)
  1631. {
  1632. PBYTE pImg24 = (PBYTE)(pSubImage->pLineAddr[j]);
  1633. for (i=0;i<m_CurWidth;i++)
  1634. {
  1635. index = pSrcData[j*m_CurWidth+i];
  1636. *pImg24++ = m_CurRgbQuad[index].rgbBlue;
  1637. *pImg24++ = m_CurRgbQuad[index].rgbGreen;
  1638. *pImg24++ = m_CurRgbQuad[index].rgbRed;
  1639. }
  1640. }
  1641. }
  1642. break;
  1643. case DF_32: // 32位格式
  1644. {
  1645. for (j=0;j<m_CurHeight;j++)
  1646. {
  1647. DWORD *pImg32 = (DWORD*)(pSubImage->pLineAddr[j]);
  1648. for (i=0;i<m_CurWidth;i++)
  1649. {
  1650. index = pSrcData[j*m_CurWidth+i];
  1651. DWORD bkc32 = _cnv_rgb_to_888( m_CurRgbQuad[index].rgbRed, 
  1652.   m_CurRgbQuad[index].rgbGreen, 
  1653.   m_CurRgbQuad[index].rgbBlue);
  1654. *pImg32++ = bkc32;
  1655. }
  1656. }
  1657. }
  1658. break;
  1659. default:
  1660. ASSERT(FALSE);
  1661. break;
  1662. }
  1664. if (m_CurSaveMode) //交叉存储
  1665. GlobalFree(pSrcData);
  1667. return TRUE;
  1668. }
  1671. // 获取GIF文件中图像的个数
  1672. // 参数pFileContent指向的缓冲区必须包括完整的GIF文件内容
  1673. // 参数filesize是指明pFileContent所指向的缓冲区的尺寸（即GIF文件的尺寸）
  1674. // 函数返回图像的个数，如果文件内容非法（比如是个受损的GIF文件），则返回0
  1675. int _get_imgcount(PBYTE pFileContent, DWORD filesize)
  1676. {
  1677. ASSERT(pFileContent);
  1678. ASSERT(pFileContent[0] == 'G');
  1680. PBYTE p = pFileContent;
  1682. GIFHEADER gifHeader; // 文件头
  1684. memcpy(&gifHeader,p,sizeof(GIFHEADER));
  1686. // 跨过GIF文件头及逻辑屏幕描述块
  1687. p += sizeof(GIFHEADER);
  1689. // 判断是否存在全局调色板，如果存在则跨过该调色板
  1690. if (gifHeader.GlobalFlagByte&0x80)
  1691. p += (1<<((gifHeader.GlobalFlagByte&0x7)+1))*sizeof(GIFRGB);
  1693. int imgcount = 0;
  1695. // 分解数据区
  1696. while (1)
  1697. {
  1698. if (p[0] == 0x21 && p[1] == 0xf9 && p[2] == 0x4) // 图形扩展块
  1699. p += sizeof(GRAPHCTRL);
  1700. else if (p[0] == 0x21 && p[1] == 0x1 && p[2] == 0xc)// 文本扩展块
  1701. p += sizeof(TEXTCTRL)-(255-((LPTEXTCTRL)p)->Data[0]);
  1702. else if (p[0] == 0x21 && p[1] == 0xff && p[2] == 0xb)// 应用程序扩展块
  1703. p += sizeof(APPCTRL)-(255-((LPAPPCTRL)p)->Data[0]);
  1704. else if (p[0] == 0x21 && p[1] == 0xfe) // 注释扩展块
  1705. p += sizeof(NOTEHCTRL)-(255-((LPNOTEHCTRL)p)->Data[0]);
  1706. else if (p[0] == 0x2c) // 图像描述符＋[局部调色板]＋图像数据块
  1707. {
  1708. IMAGEDATAINFO ImageData; // 图像数据块
  1710. // 跨过图像描述符结构
  1711. memcpy(&ImageData,p,sizeof(IMAGEDATAINFO));
  1712. p += sizeof(IMAGEDATAINFO);
  1714. // 如果拥有局部调色板数据，则跨过
  1715. if (ImageData.LocalFlagByte&0x80) 
  1716. p += (1<<(ImageData.LocalFlagByte&0x7+1))*sizeof(GIFRGB);
  1718. p++; // 越过LZW初始位值
  1720. BYTE dataLen;
  1722. // 跨过经压缩的图像数据
  1723. while (1)
  1724. {
  1725. if ((((DWORD)p)-((DWORD)pFileContent)) > filesize)
  1726. return 0; // 受损的文件
  1727. dataLen = *p++;
  1728. p += dataLen;
  1729. if (dataLen == 0x0) 
  1730. break;
  1731. }
  1732. // 图像个数加1
  1733. imgcount++;
  1734. }
  1735. else 
  1736. break;
  1738. if ((((DWORD)p)-((DWORD)pFileContent)) > filesize)
  1739. return 0; // 受损的文件
  1740. }
  1742. // 返回GIF文件中的图像个数
  1743. return imgcount;
  1744. }
  1747. // 判断标准图像的位格式
  1748. DESFORMAT _get_desformat(LPINFOSTR pInfo)
  1749. {
  1750. ASSERT(pInfo);
  1751. // ASSERT(pInfo->state >= PKST_PASSVER);
  1752. ASSERT(pInfo->sDIBInfo.bmi.biPlanes == 1);
  1754. DESFORMAT result;
  1756. switch(pInfo->sDIBInfo.bmi.biBitCount)
  1757. {
  1758. case 32:
  1759. /******************************************************
  1760. 32位掩码示意图
  1761.     高               ->                 低
  1762. 0000 0000   0000 0000   0000 0000   0000 0000  888格式
  1763.             1111 1111  ------------------------R
  1764.                         1111 1111 -------------G
  1765.                                     1111 1111--B
  1766. * Win95 系统只支持这一种格式
  1767. ******************************************************/
  1768. if (pInfo->sDIBInfo.bmi.biCompression == BI_RGB)
  1769. {
  1770. result = DF_32;
  1771. break;
  1772. }
  1774. if ((pInfo->sDIBInfo.rmask == 0xff0000)&&
  1775. (pInfo->sDIBInfo.gmask == 0xff00)&&
  1776. (pInfo->sDIBInfo.bmask == 0xff))
  1777. result = DF_32;
  1778. else
  1779. {
  1780. ASSERT(FALSE); // 只支持888格式
  1781. result = DF_NULL;
  1782. }
  1783. break;
  1784. case 24:
  1785. result = DF_24;
  1786. break;
  1787. case 16:
  1788. /*******************************************
  1789. 16位掩码示意图
  1791.   高字节      低字节
  1792. 0000 0000   0000 0000 
  1793.    1 1111--B // 555格式
  1794.    11 111 -------G
  1795.  111 11  --------------R
  1796. 0
  1797.    1 1111--B // 565格式
  1798.   111   111 -------G
  1799. 1111 1   --------------R
  1801. * Win95 系统只支持以上两种格式
  1802. *******************************************/
  1803. if (pInfo->sDIBInfo.bmi.biCompression == BI_RGB)
  1804. {
  1805. result = DF_16_555;
  1806. break;
  1807. }
  1809. if ((pInfo->sDIBInfo.rmask == 0x7c00)&&
  1810. (pInfo->sDIBInfo.gmask == 0x3e0)&&
  1811. (pInfo->sDIBInfo.bmask == 0x1f))
  1812. result = DF_16_555;
  1813. else if ((pInfo->sDIBInfo.rmask == 0xf800)&&
  1814. (pInfo->sDIBInfo.gmask == 0x7e0)&&
  1815. (pInfo->sDIBInfo.bmask == 0x1f))
  1816. result = DF_16_565;
  1817. else
  1818. result = DF_NULL;
  1819. break;
  1820. default:
  1821. ASSERT(FALSE); // 不接受其它格式
  1822. result = DF_NULL;
  1823. break;
  1824. }
  1826. return result;
  1827. }
  1830. // 将指定的RGB颜色分量转换成555格式（WORD型值返回）
  1831. WORD _cnv_rgb_to_555(BYTE red, BYTE green, BYTE blue)
  1832. {
  1833. WORD result = 0;
  1835. result = (((WORD)red>>3)<<10)|(((WORD)green>>3)<<5)|((WORD)blue>>3);
  1837. return result;
  1838. }
  1841. // 将指定的555格式的颜色转换成RGB颜色分量
  1842. void _cnv_555_to_rgb(WORD col, PBYTE red, PBYTE green, PBYTE blue)
  1843. {
  1844. // 在555转换到RGB时，将像素的亮度调到最大
  1845. *red = (BYTE)((col>>7)&0xf8);
  1846. *green = (BYTE)((col>>2)&0xf8);
  1847. *blue = (BYTE)(col<<3);
  1848. }
  1851. // 将指定的RGB颜色分量转换成565格式（WORD型值返回）
  1852. WORD _cnv_rgb_to_565(BYTE red, BYTE green, BYTE blue)
  1853. {
  1854. WORD result = 0;
  1856. result = (((WORD)red>>3)<<11)|(((WORD)green>>2)<<5)|((WORD)blue>>3);
  1858. return result;
  1859. }
  1862. // 将指定的565格式的颜色转换成RGB颜色分量
  1863. void _cnv_565_to_rgb(WORD col, PBYTE red, PBYTE green, PBYTE blue)
  1864. {
  1865. // 在565转换到RGB时，将像素的亮度调到最大
  1866. *red = (BYTE)((col>>8)&0xf8);
  1867. *green = (BYTE)((col>>3)&0xfc);
  1868. *blue = (BYTE)(col<<3);
  1869. }
  1872. // 将指定的RGB颜色分量转换成888格式（DWORD型值返回）
  1873. DWORD _cnv_rgb_to_888(BYTE red, BYTE green, BYTE blue)
  1874. {
  1875. DWORD result = 0;
  1877. result = ((DWORD)red<<16)|((DWORD)green<<8)|(DWORD)blue;
  1879. return result;
  1880. }
  1883. // 清除子图像链表
  1884. void _clear_list(void)
  1885. {
  1886. if (m_pSubimgTail == NULL)
  1887. return;
  1889. ASSERT(m_CurImgIndex);
  1891. LPSUBIMGBLOCK   lpSubImg;
  1893. while((lpSubImg=m_pSubimgTail) != NULL)
  1894. {
  1895. m_pSubimgTail = lpSubImg->prev;
  1897. lpSubImg->number = 0; // 子图像块的序列号
  1898. lpSubImg->left = lpSubImg->top = 0; // 子图像块的显示位置（左上角）
  1899. lpSubImg->width = lpSubImg->height = 0; // 子图像块的图像宽度及高度
  1900. lpSubImg->dowith = 0; // 处置方法（针对于动画GIF）
  1901. lpSubImg->userinput = 0; // 用户输入（针对于动画GIF）
  1902. lpSubImg->colorkey = 0; // 透明色分量值
  1903. lpSubImg->time = 0; // 显示的延迟时间
  1905. if (lpSubImg->pLineAddr)
  1906. ::GlobalFree(lpSubImg->pLineAddr);
  1908. if (lpSubImg->_pbdata)
  1909. ::GlobalFree(lpSubImg->_pbdata);
  1911. lpSubImg->parents = NULL; // 第一桢图像数据的结构地址（所属数据包结构的地址）
  1912. lpSubImg->prev = NULL; // 前一桢图像数据的结构地址
  1913. lpSubImg->next = NULL; // 后一桢图像数据的结构地址（NULL表示这是最后一副图像）
  1915. ::GlobalFree(lpSubImg);
  1916. };
  1918. m_pSubimgHead = NULL;
  1919. m_CurImgIndex = 0;
  1921. return;
  1922. }