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

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

图形图象

开发平台：

Visual C++

BmpModule.cpp：源码内容
  1. /********************************************************************
  3. BmpModule.cpp - ISee图像浏览器—BMP图像读写模块实现文件
  4.           
  5.     版权所有(C) 2000 VCHelp-coPathway-ISee workgroup member
  7.     这一程序是自由软件，你可以遵照自由软件基金会出版的GNU 通用公共许
  8. 可证条款来修改和重新发布这一程序。或者用许可证的第二版，或者（根
  9. 据你的选择）用任何更新的版本。
  11.     发布这一程序的目的是希望它有用，但没有任何担保。甚至没有适合特定
  12. 目地的隐含的担保。更详细的情况请参阅GNU通用公共许可证。
  14.     你应该已经和程序一起收到一份GNU通用公共许可证的副本。如果还没有，
  15. 写信给：
  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. 编写人：YZ
  27. E-Mail：yzfree@sina.com
  29. 文件版本：
  30. Beta  1.5
  31. Build 01209
  32. Date  2000-12-9
  34. ********************************************************************/
  36. #include "stdafx.h"
  37. #include "..publicgol_isee.h" // 此文件定义了接口数据包
  38. #include "BmpModule.h"
  40. #ifdef _DEBUG
  41. #define new DEBUG_NEW
  42. #undef THIS_FILE
  43. static char THIS_FILE[] = __FILE__;
  44. #endif
  46. static char ModuleProcessImgType[]="BMP,DIB,RLE"; // 本模块能处理的图像类型
  47. static char WriterList[]="YZ"; // 本模块的作者列表
  48. static char WriterMess[]="没想到做好BMP模块还真挺复杂^_^"; // 作者留言
  50. static int  RWPROGRESSSIZE;
  51. static const int RWPROGRESSSTEP = 10;
  53. //
  54. // Note!
  55. //
  56. // If this DLL is dynamically linked against the MFC
  57. // DLLs, any functions exported from this DLL which
  58. // call into MFC must have the AFX_MANAGE_STATE macro
  59. // added at the very beginning of the function.
  60. //
  61. // For example:
  62. //
  63. // extern "C" BOOL PASCAL EXPORT ExportedFunction()
  64. // {
  65. // AFX_MANAGE_STATE(AfxGetStaticModuleState());
  66. // // normal function body here
  67. // }
  68. //
  69. // It is very important that this macro appear in each
  70. // function, prior to any calls into MFC.  This means that
  71. // it must appear as the first statement within the 
  72. // function, even before any object variable declarations
  73. // as their constructors may generate calls into the MFC
  74. // DLL.
  75. //
  76. // Please see MFC Technical Notes 33 and 58 for additional
  77. // details.
  78. //
  80. // 在图像读写模块中，如果想分配内存，请使用API函数GlobalAlloc()
  81. // ，如果想释放内存请使用GlobalFree()函数。不要使用诸如：new
  82. // 、malloc()等函数。这是为了使各模块之间可以异地释放内存。
  83. //
  84. //
  86. /////////////////////////////////////////////////////////////////////////////
  87. // CBmpModuleApp
  89. BEGIN_MESSAGE_MAP(CBmpModuleApp, CWinApp)
  90. //{{AFX_MSG_MAP(CBmpModuleApp)
  91. // NOTE - the ClassWizard will add and remove mapping macros here.
  92. //    DO NOT EDIT what you see in these blocks of generated code!
  93. //}}AFX_MSG_MAP
  94. END_MESSAGE_MAP()
  96. /////////////////////////////////////////////////////////////////////////////
  97. // CBmpModuleApp construction
  99. CBmpModuleApp::CBmpModuleApp()
  100. {
  101. // TODO: add construction code here,
  102. // Place all significant initialization in InitInstance
  103. }
  105. /////////////////////////////////////////////////////////////////////////////
  106. // The one and only CBmpModuleApp object
  108. CBmpModuleApp theApp;
  111. // 接口函数声明 — 第一层，唯一与外界联系的接口
  112. int WINAPI AccessBMPModule(INFOSTR *pInfo)
  113. {
  114. // 这个函数可以不作修改的使用，除非你的返回值多于两种。
  116. switch(pInfo->comm)
  117. {
  118. case CMD_GETPROCTYPE: // 获取本模块能处理的图像类型
  119. _fnCMD_GETPROCTYPE(pInfo);
  120. break;
  121. case CMD_GETWRITERS: // 获取本模块的作者列表，多人时用逗号分隔
  122. _fnCMD_GETWRITERS(pInfo);
  123. break;
  124. case CMD_GETWRITERMESS: // 获取作者们的留言
  125. _fnCMD_GETWRITERMESS(pInfo);
  126. break;
  127. case CMD_GETBUILDID: // 获取图像模块内部版本号
  128. _fnCMD_GETBUILDID(pInfo);
  129. break;
  130. case CMD_IS_VALID_FILE: // 判断指定文件是否是有效的BMP文件
  131. _fnCMD_IS_VALID_FILE(pInfo);
  132. break;
  133. case CMD_GET_FILE_INFO: // 获取指定文件的信息
  134. _fnCMD_GET_FILE_INFO(pInfo);
  135. break;
  136. case CMD_LOAD_FROM_FILE: // 从指定图像文件中读取数据
  137. _fnCMD_LOAD_FROM_FILE(pInfo);
  138. break;
  139. case CMD_SAVE_TO_FILE: // 将数据保存到指定文件中
  140. _fnCMD_SAVE_TO_FILE(pInfo);
  141. break;
  142. case CMD_IS_SUPPORT: // 查询某个命令是否被支持
  143. _fnCMD_IS_SUPPORT(pInfo);
  144. break;
  145. case CMD_RESIZE: // 从新获取指定尺寸的图像位数据（只适用于矢量图像）
  146. _fnCMD_RESIZE(pInfo);
  147. break;
  148. default:
  149. pInfo->result = ER_ILLCOMM; // 非法命令
  150. ASSERT(FALSE); // 调用者的程序设计有问题 :-)
  151. break;
  152. }
  154. // 执行命令成功返回1, 失败返回0
  155. return (pInfo->result==ER_SUCCESS)? 1:0;
  156. }
  162. // 命令解释函数 — 第二层解释函数
  163. //********************************************************************//
  165. // 操作命令解释函数---解释：CMD_IS_SUPPORT命令
  166. // 查询某个命令是否被支持
  167. void _fnCMD_IS_SUPPORT(INFOSTR *pInfo)
  168. {
  169. // 这个函数是为客户程序查询时使用，如果你实现了对某个命令的
  170. // 解释，可修改相应的case中的设置，使其返回ER_SUCCESS，这就
  171. // 表示你的模块已经支持该命令了。同时，现在的这个文件中已包
  172. // 含了对前四个命令的解释，你只需向还未支持的命令函数中添加
  173. // 代码即可。
  175. ASSERT(pInfo->result == ER_EMPTY);
  177. switch(pInfo->annexdata.cmAnnData)  
  178. {
  179. case CMD_GETPROCTYPE: // 获取本模块能处理的图像类型
  180. pInfo->result = ER_SUCCESS;
  181. break;
  182. case CMD_GETWRITERS: // 获取本模块的作者列表，多人时用逗号分隔
  183. pInfo->result = ER_SUCCESS;
  184. break;
  185. case CMD_GETWRITERMESS: // 获取作者们的留言
  186. pInfo->result = ER_SUCCESS;
  187. break;
  188. case CMD_GETBUILDID: // 获取图像模块内部版本号
  189. pInfo->result = ER_SUCCESS;
  190. break;
  191. case CMD_IS_VALID_FILE: // 判断指定文件是否是有效的WMF文件
  192. pInfo->result = ER_SUCCESS;
  193. break;
  194. case CMD_GET_FILE_INFO: // 获取指定文件的信息
  195. pInfo->result = ER_SUCCESS;
  196. break;
  197. case CMD_LOAD_FROM_FILE: // 从指定图像文件中读取数据
  198. pInfo->result = ER_SUCCESS;
  199. break;
  200. case CMD_SAVE_TO_FILE: // 将数据保存到指定文件中
  201. pInfo->result = ER_SUCCESS;
  202. break;
  203. case CMD_IS_SUPPORT: // 查询某个命令是否被支持
  204. pInfo->result = ER_SUCCESS;
  205. break;
  206. case CMD_RESIZE: // 获取指定尺寸的图像（只适用于矢量图像）
  207. pInfo->result = ER_NOTSUPPORT;
  208. break;
  209. default:
  210. pInfo->result = ER_NOTSUPPORT;
  211. break;
  212. }
  213. }
  216. // 操作命令解释函数---解释：CMD_GETPROCTYPE命令
  217. // 获取本模块能处理的图像类型，如：BMP，PCX等等
  218. void _fnCMD_GETPROCTYPE(INFOSTR *pInfo)
  219. {
  220. // 这是预定义的函数代码，你可以不必修改的使用。
  222. // 根据接口定义，此时附加数据应被清空为0，所以下此断言
  223. ASSERT(pInfo->annexdata.scAnnData[0] == 0);
  224. ASSERT(pInfo->result == ER_EMPTY);
  225. // 复制能处理的类型字符串
  226. ::CopyMemory((PVOID)pInfo->annexdata.scAnnData, (PVOID)ModuleProcessImgType, 
  227. sizeof(ModuleProcessImgType));
  229. pInfo->result = ER_SUCCESS;
  230. }
  234. // 操作命令解释函数---解释：CMD_GETWRITER命令
  235. // 获取本模块的作者列表，多人时用逗号分隔
  236. void _fnCMD_GETWRITERS(INFOSTR *pInfo)
  237. {
  238. // 这是预定义的函数代码，你可以不必修改的使用。
  240. // 根据接口定义，此时附加数据应被清空为0，所以下此断言
  241. ASSERT(pInfo->annexdata.scAnnData[0] == 0);
  242. ASSERT(pInfo->result == ER_EMPTY);
  243. // 复制开发者名单串
  244. ::CopyMemory((PVOID)pInfo->annexdata.scAnnData, (PVOID)WriterList, 
  245. sizeof(WriterList));
  247. pInfo->result = ER_SUCCESS;
  248. }
  251. // 操作命令解释函数---解释：CMD_GETWRITERMESS命令
  252. // 获取作者们的留言
  253. void _fnCMD_GETWRITERMESS(INFOSTR *pInfo)
  254. {
  255. // 这是预定义的函数代码，你可以不必修改的使用。
  257. // 根据接口定义，此时附加数据应被清空为0，所以下此断言
  258. ASSERT(pInfo->annexdata.scAnnData[0] == 0);
  259. ASSERT(pInfo->result == ER_EMPTY);
  260. // 复制开发者们的留言字符串
  261. ::CopyMemory((PVOID)pInfo->annexdata.scAnnData, (PVOID)WriterMess, 
  262. sizeof(WriterMess));
  264. pInfo->result = ER_SUCCESS;
  265. }
  269. // 操作命令解释函数---解释：CMD_GETBUILDID命令
  270. // 获取图像模块内部版本号
  271. void _fnCMD_GETBUILDID(INFOSTR *pInfo)
  272. {
  273. // 这是预定义的函数代码，你可以不必修改的使用。
  275. // 根据接口定义，此时annexdata.dwAnnData应被设为0，所以下此断言
  276. ASSERT(pInfo->annexdata.dwAnnData == 0);
  277. ASSERT(pInfo->result == ER_EMPTY);
  278. // 填写内部版本号码
  279. pInfo->annexdata.dwAnnData = MODULE_BUILDID;
  281. pInfo->result = ER_SUCCESS;
  282. }
  286. // 操作命令解释函数---解释：CMD_IS_VALID_FILE命令
  287. // 判断指定文件是否是有效的BMP文件
  288. void _fnCMD_IS_VALID_FILE(INFOSTR *pInfo)
  289. {
  290. CFile file;
  291. BITMAPFILEHEADER bmfHeader;
  292. BITMAPINFOHEADER bmiHeader;
  293. DWORD dwSize;
  294. UINT uRet, uRet2;
  296. ASSERT(pInfo);
  298. // 检验入口参数是否符合接口定义
  299. ASSERT(pInfo->result == ER_EMPTY);
  300. ASSERT(pInfo->annexdata.iAnnData == 0);
  301. ASSERT(::strlen(pInfo->filename));
  302. ASSERT(pInfo->state == PKST_NOTVER);
  304. // 设初值
  305. pInfo->result = ER_SUCCESS;
  306. pInfo->annexdata.iAnnData = 0;
  308. // 先判断指定的文件是否存在
  309. if (!IsFileExist(pInfo->filename))
  310. pInfo->result = ER_COMMINFOERR;
  311. else
  312. {
  313. // 打开指定文件
  314. if (!file.Open(pInfo->filename, CFile::modeRead))
  315. {
  316. pInfo->result = ER_FILERWERR; // 打开文件时出错
  317. return;
  318. }
  320. // 获取BMP文件的长度（以字节为单位）
  321. dwSize = file.GetLength();
  323. // 用长度判断
  324. if (dwSize < (sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)))
  325. {
  326. // 这不是一个BMP文件，BMP文件的长度起码大于文件头
  327. // 加信息头结构的长度
  328. file.Close();
  329. return;
  330. }
  332. // 读取BMP的文件头及信息头结构，并检查它们的有效性
  333. file.SeekToBegin();
  334. uRet  = file.Read((LPSTR)&bmfHeader, sizeof(BITMAPFILEHEADER));
  335. uRet2 = file.Read((LPSTR)&bmiHeader, sizeof(BITMAPINFOHEADER));
  336. if ((uRet != sizeof(BITMAPFILEHEADER))||(uRet2 != sizeof(BITMAPINFOHEADER)))
  337. {
  338. pInfo->result = ER_FILERWERR; // 读文件时出错
  339. file.Close();
  340. return;
  341. }
  343. // 判断文件头部的位图标志（‘BM’）
  344. if (bmfHeader.bfType != DIB_HEADER_MARKER)
  345. {
  346. file.Close();
  347. return;
  348. }
  350. // 判断信息结构的尺寸
  351. switch(bmiHeader.biSize)
  352. {
  353. case sizeof(BITMAPINFOHEADER):
  354. break;
  355. default:
  356. //case sizeof(BITMAPCOREHEADER): // 不支持OS/2格式的位图
  357. //case sizeof(BITMAPV5HEADER): // 不支持NT5以上系统产生的位图
  358. //case sizeof(BITMAPV4HEADER): // 不支持Windows4.0系统产生的位图，以后支持
  359. file.Close();
  360. return;
  361. }
  363. // 检验位数据偏移地址
  364. if ((bmfHeader.bfOffBits > dwSize)||
  365. (bmfHeader.bfOffBits < (bmiHeader.biSize+sizeof(BITMAPFILEHEADER))))
  366. {
  367. file.Close();
  368. return;
  369. }
  371. // 到此，大致可以表明该文件是一个有效的BMP文件，iAnnData变量设为1
  372. pInfo->annexdata.iAnnData = 1;
  373. pInfo->state = PKST_PASSVER; // 表示通过校验
  375. file.Close();
  376. }
  377. }
  382. // 操作命令解释函数---解释：CMD_GET_FILE_INFO命令
  383. // 获取指定文件的信息
  384. void _fnCMD_GET_FILE_INFO(INFOSTR *pInfo)
  385. {
  386. CFile file;
  387. CFileStatus status;
  388. LPBITMAPINFO pDIB;
  389. BITMAPFILEHEADER bmfHeader;
  390. UINT uRet, uDibInfoSize;
  392. // 检验入口参数是否符合接口定义
  393. ASSERT(pInfo->result == ER_EMPTY);
  394. ASSERT(::strlen(pInfo->filename));
  395. // 此时，该文件必需是一个已存在的、并且是有效的BMP文件
  396. ASSERT(pInfo->state == PKST_PASSVER);
  397. // 客户模块必需要先将imginfo清空为0
  398. ASSERT(pInfo->imginfo.imgtype == IMT_NULL);
  400. // 打开指定文件
  401. if (!file.Open(pInfo->filename, CFile::modeRead))
  402. {
  403. pInfo->result = ER_FILERWERR;
  404. return;
  405. }
  407. // 读取BMP的文件头结构
  408. file.SeekToBegin();
  409. uRet  = file.Read((LPSTR)&bmfHeader, sizeof(BITMAPFILEHEADER));
  411. if (uRet != sizeof(BITMAPFILEHEADER))
  412. {
  413. file.Close();
  414. pInfo->result = ER_FILERWERR;
  415. return;
  416. }
  418. uDibInfoSize = bmfHeader.bfOffBits-sizeof(BITMAPFILEHEADER);
  420. // 分配内存，用于存放信息头及颜色表（如果有）
  421. pDIB = (LPBITMAPINFO)::GlobalAlloc(GPTR, uDibInfoSize);
  422. if (!pDIB)
  423. {
  424. file.Close();
  425. pInfo->result = ER_MEMORYERR;
  426. return;
  427. }
  429. // 读取图像信息数据
  430. file.Seek((LONG)sizeof(BITMAPFILEHEADER), CFile::begin);
  431. uRet = file.Read((void *)pDIB, uDibInfoSize);
  432. if (uRet != uDibInfoSize)
  433. {
  434. ::GlobalFree((void*)pDIB);
  435. file.Close();
  436. pInfo->result = ER_FILERWERR;
  437. return;
  438. }
  440. LPIMAGEINFOSTR lpImgInfoStr = &pInfo->imginfo;
  442. // 获取文件的长度、图像的宽度、高度等信息
  443. lpImgInfoStr->imgtype = IMT_RESSTATIC;
  444. lpImgInfoStr->imgformat = IMF_BMP;
  445. lpImgInfoStr->filesize = file.GetLength();
  446. lpImgInfoStr->width = pDIB->bmiHeader.biWidth;
  447. // 图像的高度值有时可能是负值，所以使用了abs()函数
  448. lpImgInfoStr->height = (DWORD)::abs(pDIB->bmiHeader.biHeight);
  449. lpImgInfoStr->bitcount = (DWORD)pDIB->bmiHeader.biBitCount;
  450. switch(pDIB->bmiHeader.biCompression)
  451. {
  452. case BI_RGB: //0L
  453. lpImgInfoStr->compression = ICS_RGB; break;
  454. case BI_RLE8: //1L
  455. lpImgInfoStr->compression = ICS_RLE8; break;
  456. case BI_RLE4: //2L
  457. lpImgInfoStr->compression = ICS_RLE4; break;
  458. case BI_BITFIELDS://3L
  459. lpImgInfoStr->compression = ICS_BITFIELDS; break;
  460. default:
  461. //case BI_PNG: // 以后的版本将支持这两种位格式
  462. //case BI_JPEG:
  463. ASSERT(FALSE);
  464. }
  465. // 每一图像行所占的字节数（DWORD对齐，并且只对非压缩位图有效）
  466. lpImgInfoStr->linesize = DIBSCANLINE_WIDTHBYTES(pDIB->bmiHeader.biWidth*pDIB->bmiHeader.biBitCount);
  467. lpImgInfoStr->imgnumbers = 1; // BMP文件中只有一个图像
  468. lpImgInfoStr->imgchang = 0; // 表示可以被编辑
  470. // 获取文件最后的修改日期（月在高字节，日在低字节）
  471. file.GetStatus(status);
  472. lpImgInfoStr->year = (WORD)status.m_mtime.GetYear();
  473. lpImgInfoStr->monday = (WORD)status.m_mtime.GetMonth();
  474. lpImgInfoStr->monday <<= 8;
  475. lpImgInfoStr->monday |= (WORD)status.m_mtime.GetDay();
  477. // 获取文件最后的修改时间（字序：最高—0, 2—时，1—分，0—秒）
  478. lpImgInfoStr->time = status.m_mtime.GetHour();
  479. lpImgInfoStr->time <<= 8;
  480. lpImgInfoStr->time |= status.m_mtime.GetMinute();
  481. lpImgInfoStr->time <<= 8;
  482. lpImgInfoStr->time |= status.m_mtime.GetSecond();
  483. lpImgInfoStr->time &= 0xffffff;
  485. ::GlobalFree((void*)pDIB);
  486. file.Close();
  488. // 设置出口数据
  489. pInfo->state = PKST_PASSINFO;
  490. pInfo->result = ER_SUCCESS;
  491. }
  495. // 操作命令解释函数---解释：CMD_LOAD_FROM_FILE命令
  496. // 从指定图像文件中读取数据
  497. void _fnCMD_LOAD_FROM_FILE(INFOSTR *pInfo)
  498. {
  499. // 检验入口参数是否符合接口定义
  500. ASSERT(pInfo->result == ER_EMPTY);
  501. ASSERT(::strlen(pInfo->filename));
  502. // 此时，该文件必需是一个已存在的、有效的BMP文件，并且数据包中
  503. // 含有该文件的信息（imginfo结构中）
  504. ASSERT(pInfo->state == PKST_PASSINFO);
  505. ASSERT(pInfo->imginfo.imgformat == IMF_BMP);
  506. ASSERT(pInfo->pImgInfo == NULL);
  507. // 必需设置标准图像格式信息
  508. ASSERT(pInfo->sDIBInfo.bmi.biSize == sizeof(BITMAPINFOHEADER));
  509. ASSERT(pInfo->pLineAddr != NULL);
  510. ASSERT(pInfo->_pbdata != NULL);
  512. CFile file;
  514. // 以图像的高度值作为进度总值
  515. RWPROGRESSSIZE = (int)pInfo->imginfo.height;
  517. if (pInfo->fpProgress)
  518. {
  519. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, 0))
  520. {
  521. // 如果进度函数返回1，则说明用户想中断操作，返回。
  522. pInfo->result = ER_USERBREAK;
  523. return;
  524. }
  525. }
  527. // 打开指定文件
  528. if (!file.Open(pInfo->filename, CFile::modeRead))
  529. {
  530. pInfo->result = ER_FILERWERR;
  531. return;
  532. }
  533. file.Seek(0, CFile::begin);
  535. if (pInfo->fpProgress)
  536. {
  537. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, 0))
  538. {
  539. // 如果进度函数返回1，则说明用户想中断操作，返回。
  540. file.Close();
  541. pInfo->result = ER_USERBREAK;
  542. return;
  543. }
  544. }
  546. // 读取并转换图像到数据包中
  547. if (_Read(file, pInfo) == 0)
  548. {
  549. // 成功
  550. pInfo->state = PKST_INFOANDBITS;
  551. pInfo->modify = 0;
  552. pInfo->result = ER_SUCCESS;
  553. }
  555. file.Close();
  557. if (pInfo->fpProgress) // 结束进度条，此调用不再支持用户中断
  558. (*pInfo->fpProgress)(RWPROGRESSSIZE, RWPROGRESSSIZE);
  560. }
  564. // 操作命令解释函数---解释：CMD_SAVE_TO_FILE命令
  565. // 将数据保存到指定文件中
  567. // pInfo所指向的数据包中，annexdata.siAnnData[]变量的含意解释：
  568. // [0] — 位深度，可以是1、4、8、16(555)、24、32(888)这六个值
  569. // 中的一个，不能是其他值。另：不能存储为RLE格式
  570. // [1] — 是否使用原始调色板。0 — 表示使用，1 — 表示使用当前
  571. // 计算机缺省调色板
  572. void _fnCMD_SAVE_TO_FILE(INFOSTR *pInfo)
  573. {
  574. // 检验入口参数是否符合接口定义
  575. ASSERT(pInfo->result == ER_EMPTY);
  576. // 该文件名可以是一个已存在的文件，也可以是不存在的文件（本函数将创建）。
  577. ASSERT(::strlen(pInfo->filename));
  578. ASSERT(pInfo->state == PKST_INFOANDBITS);
  579. // 必需设置标准图像格式信息
  580. ASSERT(pInfo->sDIBInfo.bmi.biSize == sizeof(BITMAPINFOHEADER));
  581. ASSERT(pInfo->pLineAddr != NULL);
  582. ASSERT(pInfo->_pbdata != NULL);
  584. CFile file;
  585. CFileStatus status;
  586. BITMAPFILEHEADER bmf;
  587. int uDibInfoSize;
  588. LPBITMAPINFO pDIB;
  589. int uRet;
  591. // 此时imginfo中的数据可能与sDIBInfo不一样，以sDIBInfo为准
  592. RWPROGRESSSIZE = (int)::abs(pInfo->sDIBInfo.bmi.biHeight);
  594. if (pInfo->fpProgress)
  595. {
  596. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, 0))
  597. { // 如果进度函数返回1，则说明用户想中断操作，返回。
  598. pInfo->result = ER_USERBREAK;
  599. return;
  600. }
  601. }
  603. // 打开指定文件（如果不存在就创建，如果存在，不截断为0长度），不
  604. // 允许其它进程写该文件
  605. if (!file.Open(pInfo->filename, CFile::modeCreate|CFile::modeNoTruncate|
  606. CFile::modeReadWrite|CFile::shareDenyWrite))
  607. {
  608. pInfo->result = ER_FILERWERR;
  609. return;
  610. }
  611. file.Seek(0, CFile::begin);
  613. LPIMAGEINFOSTR lpImgInfoStr = &pInfo->imginfo;
  615. // 读取并转换图像到数据包中
  616. if (_Save(file, pInfo) == 0)
  617. {
  618. file.Flush(); // 刷新文件的内容、尺寸、最后修改日期
  620. file.Seek(0, CFile::begin);
  621. if (file.Read((void*)&bmf, sizeof(BITMAPFILEHEADER)) != sizeof(BITMAPFILEHEADER))
  622. {
  623. file.Close();
  624. pInfo->result = ER_FILERWERR;
  625. return;
  626. }
  628. uDibInfoSize = bmf.bfOffBits-sizeof(BITMAPFILEHEADER);
  630. // 分配内存，用于存放信息头及颜色表（如果有）
  631. pDIB = (LPBITMAPINFO)::GlobalAlloc(GPTR, uDibInfoSize);
  632. if (!pDIB)
  633. {
  634. file.Close();
  635. pInfo->result = ER_MEMORYERR;
  636. return;
  637. }
  639. // 读取图像信息数据
  640. file.Seek((LONG)sizeof(BITMAPFILEHEADER), CFile::begin);
  641. uRet = file.Read((void *)pDIB, uDibInfoSize);
  642. if (uRet != uDibInfoSize)
  643. {
  644. ::GlobalFree((void*)pDIB);
  645. file.Close();
  646. pInfo->result = ER_FILERWERR;
  647. return;
  648. }
  650. if (pInfo->pImgInfo) // 释放图像的原始信息块
  651. ::GlobalFree((void*)pInfo->pImgInfo);
  653. pInfo->pImgInfo = (void*)pDIB; // 设置原始信息块
  655. // 获取文件的长度、图像的宽度、高度等信息
  656. lpImgInfoStr->imgtype = IMT_RESSTATIC;
  657. lpImgInfoStr->imgformat = IMF_BMP;
  658. lpImgInfoStr->filesize = file.GetLength();
  659. lpImgInfoStr->width = pInfo->sDIBInfo.bmi.biWidth;
  660. // 图像的高度值有时可能是负值，所以使用了abs()函数
  661. lpImgInfoStr->height = (DWORD)::abs(pInfo->sDIBInfo.bmi.biHeight);
  662. lpImgInfoStr->bitcount = (DWORD)pInfo->annexdata.siAnnData[0]; // 新的位深度值
  663. lpImgInfoStr->compression = ICS_RGB; // 写函数当前只支持BI_RGB格式
  665. // 每一图像行所占的字节数（DWORD对齐，并且只对非压缩位图有效）
  666. lpImgInfoStr->linesize = DIBSCANLINE_WIDTHBYTES(lpImgInfoStr->width*lpImgInfoStr->bitcount);
  667. lpImgInfoStr->imgnumbers = 1; // BMP文件中只有一个图像
  668. lpImgInfoStr->imgchang = 0; // 表示可以被编辑
  670. // 获取文件最后的修改日期（月在高字节，日在低字节）
  671. file.GetStatus(status);
  672. lpImgInfoStr->year = (WORD)status.m_mtime.GetYear();
  673. lpImgInfoStr->monday = (WORD)status.m_mtime.GetMonth();
  674. lpImgInfoStr->monday <<= 8;
  675. lpImgInfoStr->monday |= (WORD)status.m_mtime.GetDay();
  677. // 获取文件最后的修改时间（字序：最高—0, 2—时，1—分，0—秒）
  678. lpImgInfoStr->time = status.m_mtime.GetHour();
  679. lpImgInfoStr->time <<= 8;
  680. lpImgInfoStr->time |= status.m_mtime.GetMinute();
  681. lpImgInfoStr->time <<= 8;
  682. lpImgInfoStr->time |= status.m_mtime.GetSecond();
  683. lpImgInfoStr->time &= 0xffffff;
  685. // 成功
  686. pInfo->result = ER_SUCCESS;
  687. }
  689. file.Close();
  691. if (pInfo->fpProgress) // 结束进度条，此调用不再支持用户中断
  692. (*pInfo->fpProgress)(RWPROGRESSSIZE, RWPROGRESSSIZE);
  693. }
  698. // 操作命令解释函数---解释：CMD_RESIZE命令
  699. // 重新获取指定尺寸的图像位数据（只适用于矢量图像）
  700. void _fnCMD_RESIZE(INFOSTR *pInfo)
  701. {
  702. // 这个命令一般的图像读写模块不需要支持，它只适用于矢量图像，
  703. // 比如WMF、EMF之类。
  704. // 如果你想解释该命令，请在下面加入代码，并修改pInfo->result的返回值：
  705. // ----------------------------------------------------------------->
  707. pInfo->result = ER_NOTSUPPORT;
  708. }
  712. /*************************************************************************
  713.  *
  714.  * IsFileExist()
  715.  * 
  716.  * 参数说明：
  717.  *
  718.  * char *lpFileName - 待判断的文件路径和名称（文件名）
  719.  *
  720.  * 返回值：
  721.  *
  722.  * BOOL - 如果指定的文件存在返回TRUE，否则返回FALSE。
  723.  * 
  724.  * 描述：
  725.  *
  726.  * 判断指定的文件是否存在
  727.  * 
  728.  * 该文件必需可以被读和写
  729.  *
  730.  ************************************************************************/
  733. BOOL IsFileExist(char *lpFileName)
  734. {
  735. CFile file;
  736. BOOL bExist = FALSE; // 文件存在是TRUE，不存在是FALSE
  737. CFileException e;
  739. // 确定指定的文件是否存在
  740. if (file.Open(lpFileName, CFile::modeReadWrite|CFile::shareDenyNone, &e))
  741. {
  742. bExist = TRUE;
  743. file.Close();
  744. }
  745. else
  746. {
  747. // 可能有其他程序正在处理此文件
  748. switch(e.m_cause)
  749. {
  750. case CFileException::tooManyOpenFiles:
  751. case CFileException::accessDenied:
  752. case CFileException::sharingViolation:
  753. case CFileException::lockViolation:
  754. return TRUE;
  755. case CFileException::fileNotFound:
  756. case CFileException::badPath:
  757. case CFileException::invalidFile:
  758. case CFileException::hardIO:
  759. default:
  760. return FALSE;
  761. }
  762. }
  764. return bExist;
  765. }
  768. // 将指定文件读入目标缓冲区
  769. int _Read(CFile& file, LPINFOSTR pInfo)
  770. {
  771. RGBQUAD *pPalette;
  772. int imgorg;
  773. BITMAPFILEHEADER bmfHeader;
  774. BITMAPINFOHEADER bmiHeader;
  775. PBYTE pBits;
  776. PBYTE pImgInfo;
  777. DWORD dwSize, dwRet;
  778. UINT uRet;
  780. /* 读取DIB的文件头结构 */
  781. file.SeekToBegin();
  782. uRet   = file.Read((LPSTR)&bmfHeader, sizeof(BITMAPFILEHEADER));
  783. uRet  += file.Read((LPSTR)&bmiHeader, sizeof(BITMAPINFOHEADER));
  784. if (uRet != (sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)))
  785. {
  786. pInfo->result = ER_FILERWERR;
  787. return 1; // 读文件时出错
  788. }
  790. // pImgInfo将包含位图信息结构及调色板信息（如果有的话）
  791. pImgInfo = (PBYTE)::GlobalAlloc(GPTR, bmfHeader.bfOffBits-sizeof(BITMAPFILEHEADER));
  792. if (pImgInfo == NULL)
  793. {
  794. pInfo->result = ER_MEMORYERR;
  795. return 2; // 内存不足
  796. }
  798. // 读取位图文件的原始信息
  799. file.Seek(sizeof(BITMAPFILEHEADER), CFile::begin);
  800. uRet = file.Read((void*)pImgInfo, bmfHeader.bfOffBits-sizeof(BITMAPFILEHEADER));
  801. if (uRet != (bmfHeader.bfOffBits-sizeof(BITMAPFILEHEADER)))
  802. {
  803. ::GlobalFree(pImgInfo);
  804. pInfo->result = ER_FILERWERR;
  805. return 1;
  806. }
  808. // 正常情况下，高度值不会是负值或0
  809. ASSERT(RWPROGRESSSIZE > 0);
  811. if (pInfo->fpProgress)
  812. {
  813. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, 0))
  814. {
  815. // 如果进度函数返回1，则说明用户想中断操作，返回。
  816. ::GlobalFree(pImgInfo);
  817. pInfo->result = ER_USERBREAK;
  818. return 4; // 用户中断操作
  819. }
  820. }
  822. // 获取文件长度
  823. dwSize = file.GetLength();
  825. // 分配内存，用于存放位数据
  826. pBits = (PBYTE)::GlobalAlloc(GPTR, dwSize-bmfHeader.bfOffBits);
  827. if (!pBits)
  828. {
  829. ::GlobalFree(pImgInfo);
  830. pInfo->result = ER_MEMORYERR;
  831. return 2; // 内存不足
  832. }
  834. // 读取位数据
  835. file.Seek(bmfHeader.bfOffBits, CFile::begin);
  836. dwRet = file.ReadHuge((void*)pBits, (dwSize-bmfHeader.bfOffBits));
  838. if (dwRet != (dwSize-bmfHeader.bfOffBits))
  839. {
  840. ::GlobalFree(pImgInfo);
  841. ::GlobalFree(pBits);
  842. pInfo->result = ER_FILERWERR;
  843. return 1;
  844. }
  846. if (pInfo->fpProgress)
  847. {
  848. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, 0))
  849. {
  850. // 如果进度函数返回1，则说明用户想中断操作，返回。
  851. ::GlobalFree(pImgInfo);
  852. ::GlobalFree(pBits);
  853. pInfo->result = ER_USERBREAK;
  854. return 4; // 用户中断操作
  855. }
  856. }
  858. // 下面的读取函数需要该指针，所以在此处赋值
  859. pInfo->pImgInfo = pImgInfo;
  861. pPalette = (RGBQUAD*)(pImgInfo+bmiHeader.biSize);
  862. imgorg = (bmiHeader.biHeight > 0) ? 0:1; // 0-为倒向位图  1-为正向
  863. int result = 0; // 接收各函数的返回值
  865. // 根据位图文件的位深度的不同而调用相应的读取函数
  866. switch(_get_souformat((LPBITMAPINFO)pImgInfo))
  867. {
  868. case SF_1:
  869. result = _from_1_read(pInfo, pBits, imgorg, pPalette);
  870. break;
  871. case SF_4:
  872. result = _from_4_read(pInfo, pBits, imgorg, pPalette);
  873. break;
  874. case SF_4_RLE:
  875. result = _from_4_RLE_read(pInfo, pBits, imgorg, pPalette);
  876. break;
  877. case SF_8:
  878. result = _from_8_read(pInfo, pBits, imgorg, pPalette);
  879. break;
  880. case SF_8_RLE:
  881. result = _from_8_RLE_read(pInfo, pBits, imgorg, pPalette);
  882. break;
  883. case SF_16_555:
  884. result = _from_16_555_read(pInfo, pBits, imgorg);
  885. break;
  886. case SF_16_565:
  887. result = _from_16_565_read(pInfo, pBits, imgorg);
  888. break;
  889. case SF_24:
  890. result = _from_24_read(pInfo, pBits, imgorg);
  891. break;
  892. case SF_32:
  893. result = _from_32_read(pInfo, pBits, imgorg);
  894. break;
  895. default:
  896. ::GlobalFree(pImgInfo);
  897. ::GlobalFree(pBits);
  898. pInfo->pImgInfo = NULL;
  899. pInfo->result = ER_SYSERR;
  900. return 3; // 图像文件格式异常
  901. }
  903. // 释放从文件中读取的位数据（此数据已被转换并保存到了数据包中）
  904. ::GlobalFree(pBits);
  906. if (result == 0) // 执行成功
  907. {
  908. pInfo->result = ER_SUCCESS;
  909. }
  910. else
  911. {
  912. ::GlobalFree(pImgInfo);
  913. pInfo->pImgInfo = NULL;
  914. return 4; // 执行过程中产生的错误，详见pInfo->result
  915. }
  917. return 0;
  918. }
  922. // 将1位（即单色）位图转换为指定的标准格式位图
  923. // pInfo中的目标图像缓冲区必需已经被分配，且其中的源图像信息结构已被正确填写
  924. // imgorg参数是源图像的扫描行次序标志：0-为倒向 1-为正向
  925. int _from_1_read(LPINFOSTR pInfo, PBYTE lpSou, int imgorg, RGBQUAD *lpPalette)
  926. {
  927. ASSERT(pInfo);
  928. ASSERT(lpPalette); // 单色位图应有两个调色板项
  929. ASSERT(pInfo->state >= PKST_PASSINFO);
  930. ASSERT(lpSou);
  932. int sImgOrg = imgorg; // 源图像扫描行次序的标志：0-为倒向 1-为正向
  933. // 源图像的次序由调用者传入
  935. int imgheight = pInfo->imginfo.height; // 图像的高度
  936. int imgwidth  = pInfo->imginfo.width; // 图像的宽度
  937. int scansize  = pInfo->imginfo.linesize;// 每一扫描行的宽度(in byte)
  938. int heigCount, widthCount, i, j, isou;
  939. ASSERT(pInfo->pImgInfo);
  940. int palnum = ((BITMAPINFOHEADER*)(pInfo->pImgInfo))->biClrUsed;
  941. PBYTE pCurPixAddr;
  942. BYTE pix; // 当前8个像素
  944. palnum = (palnum == 0) ? 2:palnum; // 计算调色板项的实际个数
  945. ASSERT(palnum <= 2);
  947. switch(_get_desformat(pInfo)) // 标准图像格式（目标格式）
  948. {
  949. case DF_16_555:
  950. {
  951. // 以555位格式的调色板数据
  952. WORD descol555_0 = 0;
  953. WORD descol555_1 = 0;
  955. if (palnum > 0)
  956. descol555_0 = _cnv_rgb_to_555(lpPalette[0].rgbRed, lpPalette[0].rgbGreen, lpPalette[0].rgbBlue);
  957. if (palnum > 1)
  958. descol555_1 = _cnv_rgb_to_555(lpPalette[1].rgbRed, lpPalette[1].rgbGreen, lpPalette[1].rgbBlue);
  960. WORD *pDesPixAddr555;
  962. if (sImgOrg == 0) // 源图是倒向位图
  963. {
  964. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  965. {
  966. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  967. pDesPixAddr555  = (WORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  968. for (widthCount=0;widthCount<imgwidth;widthCount+=8)
  969. {
  970. pix = *pCurPixAddr++;
  972. if ((imgwidth-widthCount)<8) // 结尾判断
  973. j = imgwidth-widthCount;
  974. else
  975. j = 8;
  977. for (i=0;i<j;i++)
  978. {
  979. // 最高位代表最左面的像素
  980. if (((BYTE)(0x80>>i))&pix) // 此位被设置
  981. {
  982. *pDesPixAddr555++ = descol555_1;
  983. }
  984. else
  985. {
  986. *pDesPixAddr555++ = descol555_0;
  987. }
  988. }
  989. }
  990. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  991. {
  992. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  993. {
  994. // 如果进度函数返回1，则说明用户想中断操作，返回。
  995. pInfo->result = ER_USERBREAK;
  996. return 1; // 用户中断操作
  997. }
  998. }
  999. }
  1000. }
  1001. else // 正向位图（top-down）
  1002. {
  1003. for (heigCount=0;heigCount<imgheight;heigCount++)
  1004. {
  1005. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1006. pDesPixAddr555  = (WORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  1007. for (widthCount=0;widthCount<imgwidth;widthCount+=8)
  1008. {
  1009. pix = *pCurPixAddr++;
  1011. if ((imgwidth-widthCount)<8) // 结尾判断
  1012. j = imgwidth-widthCount;
  1013. else
  1014. j = 8;
  1016. for (i=0;i<j;i++)
  1017. {
  1018. if (((BYTE)(0x80>>i))&pix) // 此位被设置
  1019. {
  1020. *pDesPixAddr555++ = descol555_1;
  1021. }
  1022. else
  1023. {
  1024. *pDesPixAddr555++ = descol555_0;
  1025. }
  1026. }
  1027. }
  1028. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  1029. {
  1030. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  1031. {
  1032. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1033. pInfo->result = ER_USERBREAK;
  1034. return 1; // 用户中断操作
  1035. }
  1036. }
  1037. }
  1038. }
  1039. }
  1040. break;
  1041. case DF_16_565:
  1042. {
  1043. // 以565位格式的调色板数据
  1044. WORD descol565_0 = 0;
  1045. WORD descol565_1 = 0;
  1047. if (palnum > 0)
  1048. descol565_0 = _cnv_rgb_to_565(lpPalette[0].rgbRed, lpPalette[0].rgbGreen, lpPalette[0].rgbBlue);
  1049. if (palnum > 1)
  1050. descol565_1 = _cnv_rgb_to_565(lpPalette[1].rgbRed, lpPalette[1].rgbGreen, lpPalette[1].rgbBlue);
  1052. WORD *pDesPixAddr565;
  1054. if (sImgOrg == 0) // 源图是倒向位图
  1055. {
  1056. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  1057. {
  1058. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1059. pDesPixAddr565  = (WORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  1060. for (widthCount=0;widthCount<imgwidth;widthCount+=8)
  1061. {
  1062. pix = *pCurPixAddr++;
  1064. if ((imgwidth-widthCount)<8) // 结尾判断
  1065. j = imgwidth-widthCount;
  1066. else
  1067. j = 8;
  1069. for (i=0;i<j;i++)
  1070. {
  1071. if (((BYTE)(0x80>>i))&pix) // 此位被设置
  1072. {
  1073. *pDesPixAddr565++ = descol565_1;
  1074. }
  1075. else
  1076. {
  1077. *pDesPixAddr565++ = descol565_0;
  1078. }
  1079. }
  1080. }
  1081. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  1082. {
  1083. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  1084. {
  1085. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1086. pInfo->result = ER_USERBREAK;
  1087. return 1; // 用户中断操作
  1088. }
  1089. }
  1090. }
  1091. }
  1092. else // 正向位图（top-down）
  1093. {
  1094. for (heigCount=0;heigCount<imgheight;heigCount++)
  1095. {
  1096. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1097. pDesPixAddr565  = (WORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  1098. for (widthCount=0;widthCount<imgwidth;widthCount+=8)
  1099. {
  1100. pix = *pCurPixAddr++;
  1102. if ((imgwidth-widthCount)<8) // 结尾判断
  1103. j = imgwidth-widthCount;
  1104. else
  1105. j = 8;
  1107. for (i=0;i<j;i++)
  1108. {
  1109. if (((BYTE)(0x80>>i))&pix) // 此位被设置
  1110. {
  1111. *pDesPixAddr565++ = descol565_1;
  1112. }
  1113. else
  1114. {
  1115. *pDesPixAddr565++ = descol565_0;
  1116. }
  1117. }
  1118. }
  1119. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  1120. {
  1121. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  1122. {
  1123. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1124. pInfo->result = ER_USERBREAK;
  1125. return 1; // 用户中断操作
  1126. }
  1127. }
  1128. }
  1129. }
  1130. }
  1131. break;
  1132. case DF_24:
  1133. {
  1134. // 24位格式的调色板数据
  1135. BYTE red0, red1, green0, green1, blue0, blue1;
  1137. if (palnum > 0)
  1138. {
  1139. red0 = lpPalette[0].rgbRed;
  1140. green0 = lpPalette[0].rgbGreen;
  1141. blue0 = lpPalette[0].rgbBlue;
  1142. }
  1143. if (palnum > 1)
  1144. {
  1145. red1 = lpPalette[1].rgbRed;
  1146. green1 = lpPalette[1].rgbGreen;
  1147. blue1 = lpPalette[1].rgbBlue;
  1148. }
  1150. PBYTE pDesPixAddr24;
  1152. if (sImgOrg == 0) // 源图是倒向位图
  1153. {
  1154. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  1155. {
  1156. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1157. pDesPixAddr24  = (PBYTE)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  1158. for (widthCount=0;widthCount<imgwidth;widthCount+=8)
  1159. {
  1160. pix = *pCurPixAddr++;
  1162. if ((imgwidth-widthCount)<8) // 结尾判断
  1163. j = imgwidth-widthCount;
  1164. else
  1165. j = 8;
  1167. for (i=0;i<j;i++)
  1168. {
  1169. if (((BYTE)(0x80>>i))&pix) // 此位被设置
  1170. {
  1171. *pDesPixAddr24++ = blue1;
  1172. *pDesPixAddr24++ = green1;
  1173. *pDesPixAddr24++ = red1;
  1174. }
  1175. else
  1176. {
  1177. *pDesPixAddr24++ = blue0;
  1178. *pDesPixAddr24++ = green0;
  1179. *pDesPixAddr24++ = red0;
  1180. }
  1181. }
  1182. }
  1183. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  1184. {
  1185. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  1186. {
  1187. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1188. pInfo->result = ER_USERBREAK;
  1189. return 1; // 用户中断操作
  1190. }
  1191. }
  1192. }
  1193. }
  1194. else // 正向位图（top-down）
  1195. {
  1196. for (heigCount=0;heigCount<imgheight;heigCount++)
  1197. {
  1198. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1199. pDesPixAddr24  = (PBYTE)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  1200. for (widthCount=0;widthCount<imgwidth;widthCount+=8)
  1201. {
  1202. pix = *pCurPixAddr++;
  1204. if ((imgwidth-widthCount)<8) // 结尾判断
  1205. j = imgwidth-widthCount;
  1206. else
  1207. j = 8;
  1209. for (i=0;i<j;i++)
  1210. {
  1211. if (((BYTE)(0x80>>i))&pix) // 此位被设置
  1212. {
  1213. *pDesPixAddr24++ = blue1;
  1214. *pDesPixAddr24++ = green1;
  1215. *pDesPixAddr24++ = red1;
  1216. }
  1217. else
  1218. {
  1219. *pDesPixAddr24++ = blue0;
  1220. *pDesPixAddr24++ = green0;
  1221. *pDesPixAddr24++ = red0;
  1222. }
  1223. }
  1224. }
  1225. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  1226. {
  1227. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  1228. {
  1229. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1230. pInfo->result = ER_USERBREAK;
  1231. return 1; // 用户中断操作
  1232. }
  1233. }
  1234. }
  1235. }
  1236. }
  1237. break;
  1238. case DF_32:
  1239. {
  1240. // 以888位格式的调色板数据
  1241. DWORD descol888_0 = 0;
  1242. DWORD descol888_1 = 0;
  1244. if (palnum > 0)
  1245. descol888_0 = _cnv_rgb_to_888(lpPalette[0].rgbRed, lpPalette[0].rgbGreen, lpPalette[0].rgbBlue);
  1246. if (palnum > 1)
  1247. descol888_1 = _cnv_rgb_to_888(lpPalette[1].rgbRed, lpPalette[1].rgbGreen, lpPalette[1].rgbBlue);
  1249. DWORD *pDesPixAddr888;
  1251. if (sImgOrg == 0) // 源图是倒向位图
  1252. {
  1253. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  1254. {
  1255. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1256. pDesPixAddr888  = (DWORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  1257. for (widthCount=0;widthCount<imgwidth;widthCount+=8)
  1258. {
  1259. pix = *pCurPixAddr++;
  1261. if ((imgwidth-widthCount)<8) // 结尾判断
  1262. j = imgwidth-widthCount;
  1263. else
  1264. j = 8;
  1266. for (i=0;i<j;i++)
  1267. {
  1268. if (((BYTE)(0x80>>i))&pix) // 此位被设置
  1269. {
  1270. *pDesPixAddr888++ = descol888_1;
  1271. }
  1272. else
  1273. {
  1274. *pDesPixAddr888++ = descol888_0;
  1275. }
  1276. }
  1277. }
  1278. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  1279. {
  1280. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  1281. {
  1282. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1283. pInfo->result = ER_USERBREAK;
  1284. return 1; // 用户中断操作
  1285. }
  1286. }
  1287. }
  1288. }
  1289. else // 正向位图（top-down）
  1290. {
  1291. for (heigCount=0;heigCount<imgheight;heigCount++)
  1292. {
  1293. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1294. pDesPixAddr888  = (DWORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  1295. for (widthCount=0;widthCount<imgwidth;widthCount+=8)
  1296. {
  1297. pix = *pCurPixAddr++;
  1299. if ((imgwidth-widthCount)<8) // 结尾判断
  1300. j = imgwidth-widthCount;
  1301. else
  1302. j = 8;
  1304. for (i=0;i<j;i++)
  1305. {
  1306. if (((BYTE)(0x80>>i))&pix) // 此位被设置
  1307. {
  1308. *pDesPixAddr888++ = descol888_1;
  1309. }
  1310. else
  1311. {
  1312. *pDesPixAddr888++ = descol888_0;
  1313. }
  1314. }
  1315. }
  1316. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  1317. {
  1318. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  1319. {
  1320. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1321. pInfo->result = ER_USERBREAK;
  1322. return 1; // 用户中断操作
  1323. }
  1324. }
  1325. }
  1326. }
  1327. }
  1328. break;
  1329. case DF_NULL:
  1330. default:
  1331. ASSERT(FALSE);
  1332. pInfo->result = ER_ILLCOMM;
  1333. return -1;
  1334. break;
  1335. }
  1336. return 0;
  1337. }
  1341. // 将4位（即16色）位图转换为指定的标准格式位图
  1342. // pInfo中的目标图像缓冲区必需已经被分配，且其中的源图像信息结构已被正确填写
  1343. // imgorg参数是源图像的扫描行次序标志：0-为倒向 1-为正向
  1344. int _from_4_read(LPINFOSTR pInfo, PBYTE lpSou, int imgorg, RGBQUAD *lpPalette)
  1345. {
  1346. ASSERT(pInfo);
  1347. ASSERT(lpPalette); // 16色位图应有调色板
  1348. ASSERT(pInfo->state >= PKST_PASSINFO);
  1349. ASSERT(lpSou);
  1351. int imgheight = pInfo->imginfo.height; // 图像的高度
  1352. int imgwidth  = pInfo->imginfo.width; // 图像的宽度
  1353. int scansize  = pInfo->imginfo.linesize;// 每一扫描行的宽度(in byte)
  1354. int heigCount, widthCount, i, j, isou;
  1355. ASSERT(pInfo->pImgInfo);
  1356. int palnum = ((BITMAPINFOHEADER*)(pInfo->pImgInfo))->biClrUsed;
  1357. PBYTE pCurPixAddr;
  1358. BYTE pix; // 当前2个像素
  1360. palnum = (palnum == 0) ? 16:palnum; // 计算调色板项的实际个数
  1361. ASSERT(palnum <= 16);
  1363. switch(_get_desformat(pInfo)) // 标准图像格式（目标格式）
  1364. {
  1365. case DF_16_555:
  1366. {
  1367. // 以555位格式的调色板数据
  1368. WORD descol555[16];
  1369. for (i=0;i<palnum;i++) // 初始化色素颜色数据
  1370. descol555[i] = _cnv_rgb_to_555(lpPalette[i].rgbRed, lpPalette[i].rgbGreen, lpPalette[i].rgbBlue);
  1372. WORD *pDesPixAddr555;
  1374. if (imgorg == 0) // 源图是倒向位图
  1375. {
  1376. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  1377. {
  1378. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1379. pDesPixAddr555  = (WORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  1380. for (widthCount=0;widthCount<imgwidth;widthCount+=2)
  1381. {
  1382. pix = *pCurPixAddr++;
  1384. if ((imgwidth-widthCount)<2) // 结尾判断
  1385. j = imgwidth-widthCount;
  1386. else
  1387. j = 2;
  1389. for (i=0;i<j;i++)
  1390. {
  1391. if (i==0)
  1392. *pDesPixAddr555++ = descol555[pix>>4];
  1393. else
  1394. *pDesPixAddr555++ = descol555[pix&0xf];
  1395. }
  1396. }
  1397. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  1398. {
  1399. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  1400. {
  1401. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1402. pInfo->result = ER_USERBREAK;
  1403. return 1; // 用户中断操作
  1404. }
  1405. }
  1406. }
  1407. }
  1408. else // 正向位图（top-down）
  1409. {
  1410. for (heigCount=0;heigCount<imgheight;heigCount++)
  1411. {
  1412. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1413. pDesPixAddr555  = (WORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  1414. for (widthCount=0;widthCount<imgwidth;widthCount+=2)
  1415. {
  1416. pix = *pCurPixAddr++;
  1418. if ((imgwidth-widthCount)<2) // 结尾判断
  1419. j = imgwidth-widthCount;
  1420. else
  1421. j = 2;
  1423. for (i=0;i<j;i++)
  1424. {
  1425. if (i==0)
  1426. *pDesPixAddr555++ = descol555[pix>>4];
  1427. else
  1428. *pDesPixAddr555++ = descol555[pix&0xf];
  1429. }
  1430. }
  1431. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  1432. {
  1433. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  1434. {
  1435. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1436. pInfo->result = ER_USERBREAK;
  1437. return 1; // 用户中断操作
  1438. }
  1439. }
  1440. }
  1441. }
  1442. }
  1443. break;
  1444. case DF_16_565:
  1445. {
  1446. // 以565位格式的调色板数据
  1447. WORD descol565[16];
  1448. for (i=0;i<palnum;i++) // 初始化色素颜色数据
  1449. descol565[i] = _cnv_rgb_to_565(lpPalette[i].rgbRed, lpPalette[i].rgbGreen, lpPalette[i].rgbBlue);
  1451. WORD *pDesPixAddr565;
  1453. if (imgorg == 0) // 源图是倒向位图
  1454. {
  1455. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  1456. {
  1457. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1458. pDesPixAddr565  = (WORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  1459. for (widthCount=0;widthCount<imgwidth;widthCount+=2)
  1460. {
  1461. pix = *pCurPixAddr++;
  1463. if ((imgwidth-widthCount)<2) // 结尾判断
  1464. j = imgwidth-widthCount;
  1465. else
  1466. j = 2;
  1468. for (i=0;i<j;i++)
  1469. {
  1470. if (i==0)
  1471. *pDesPixAddr565++ = descol565[pix>>4];
  1472. else
  1473. *pDesPixAddr565++ = descol565[pix&0xf];
  1474. }
  1475. }
  1476. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  1477. {
  1478. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  1479. {
  1480. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1481. pInfo->result = ER_USERBREAK;
  1482. return 1; // 用户中断操作
  1483. }
  1484. }
  1485. }
  1486. }
  1487. else // 正向位图（top-down）
  1488. {
  1489. for (heigCount=0;heigCount<imgheight;heigCount++)
  1490. {
  1491. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1492. pDesPixAddr565  = (WORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  1493. for (widthCount=0;widthCount<imgwidth;widthCount+=2)
  1494. {
  1495. pix = *pCurPixAddr++;
  1497. if ((imgwidth-widthCount)<2) // 结尾判断
  1498. j = imgwidth-widthCount;
  1499. else
  1500. j = 2;
  1502. for (i=0;i<j;i++)
  1503. {
  1504. if (i==0)
  1505. *pDesPixAddr565++ = descol565[pix>>4];
  1506. else
  1507. *pDesPixAddr565++ = descol565[pix&0xf];
  1508. }
  1509. }
  1510. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  1511. {
  1512. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  1513. {
  1514. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1515. pInfo->result = ER_USERBREAK;
  1516. return 1; // 用户中断操作
  1517. }
  1518. }
  1519. }
  1520. }
  1521. }
  1522. break;
  1523. case DF_24:
  1524. {
  1525. int index24_0, index24_1;
  1527. PBYTE pDesPixAddr24;
  1529. if (imgorg  == 0) // 源图是倒向位图
  1530. {
  1531. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  1532. {
  1533. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1534. pDesPixAddr24  = (PBYTE)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  1535. for (widthCount=0;widthCount<imgwidth;widthCount+=2)
  1536. {
  1537. pix = *pCurPixAddr++;
  1539. if ((imgwidth-widthCount)<2) // 结尾判断
  1540. j = imgwidth-widthCount;
  1541. else
  1542. j = 2;
  1544. index24_0 = (int)(pix>>4);
  1545. index24_1 = (int)(pix&0xf);
  1547. for (i=0;i<j;i++)
  1548. {
  1549. if (i==0)
  1550. {
  1551. *pDesPixAddr24++ = lpPalette[index24_0].rgbBlue;
  1552. *pDesPixAddr24++ = lpPalette[index24_0].rgbGreen;
  1553. *pDesPixAddr24++ = lpPalette[index24_0].rgbRed;
  1554. }
  1555. else
  1556. {
  1557. *pDesPixAddr24++ = lpPalette[index24_1].rgbBlue;
  1558. *pDesPixAddr24++ = lpPalette[index24_1].rgbGreen;
  1559. *pDesPixAddr24++ = lpPalette[index24_1].rgbRed;
  1560. }
  1561. }
  1562. }
  1563. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  1564. {
  1565. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  1566. {
  1567. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1568. pInfo->result = ER_USERBREAK;
  1569. return 1; // 用户中断操作
  1570. }
  1571. }
  1572. }
  1573. }
  1574. else // 正向位图（top-down）
  1575. {
  1576. for (heigCount=0;heigCount<imgheight;heigCount++)
  1577. {
  1578. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1579. pDesPixAddr24  = (PBYTE)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  1580. for (widthCount=0;widthCount<imgwidth;widthCount+=2)
  1581. {
  1582. pix = *pCurPixAddr++;
  1584. if ((imgwidth-widthCount)<2) // 结尾判断
  1585. j = imgwidth-widthCount;
  1586. else
  1587. j = 2;
  1589. index24_0 = (int)(pix>>4);
  1590. index24_1 = (int)(pix&0xf);
  1592. for (i=0;i<j;i++)
  1593. {
  1594. if (i==0)
  1595. {
  1596. *pDesPixAddr24++ = lpPalette[index24_0].rgbBlue;
  1597. *pDesPixAddr24++ = lpPalette[index24_0].rgbGreen;
  1598. *pDesPixAddr24++ = lpPalette[index24_0].rgbRed;
  1599. }
  1600. else
  1601. {
  1602. *pDesPixAddr24++ = lpPalette[index24_1].rgbBlue;
  1603. *pDesPixAddr24++ = lpPalette[index24_1].rgbGreen;
  1604. *pDesPixAddr24++ = lpPalette[index24_1].rgbRed;
  1605. }
  1606. }
  1607. }
  1608. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  1609. {
  1610. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  1611. {
  1612. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1613. pInfo->result = ER_USERBREAK;
  1614. return 1; // 用户中断操作
  1615. }
  1616. }
  1617. }
  1618. }
  1619. }
  1620. break;
  1621. case DF_32:
  1622. {
  1623. // 以888位格式的调色板数据
  1624. DWORD descol888[16];
  1625. for (i=0;i<palnum;i++) // 初始化色素颜色数据
  1626. descol888[i] = _cnv_rgb_to_888(lpPalette[i].rgbRed, lpPalette[i].rgbGreen, lpPalette[i].rgbBlue);
  1628. DWORD *pDesPixAddr888;
  1630. if (imgorg == 0) // 源图是倒向位图
  1631. {
  1632. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  1633. {
  1634. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1635. pDesPixAddr888  = (DWORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  1636. for (widthCount=0;widthCount<imgwidth;widthCount+=2)
  1637. {
  1638. pix = *pCurPixAddr++;
  1640. if ((imgwidth-widthCount)<2) // 结尾判断
  1641. j = imgwidth-widthCount;
  1642. else
  1643. j = 2;
  1645. for (i=0;i<j;i++)
  1646. {
  1647. // 注：在4位位图中，每个字节的高4位代表两个像素
  1648. //     中左面的那个像素，例如某扫描行的第一个像
  1649. //     素是红色，第二个像素是白色，红的索引是A,
  1650. //     白的索引是9，那么就应该写成9A，而不能写成
  1651. //     A9，虽然习惯、逻辑上是那样。
  1652. if (i == 0)
  1653. *pDesPixAddr888++ = descol888[pix>>4];
  1654. else
  1655. *pDesPixAddr888++ = descol888[pix&0xf];
  1656. }
  1657. }
  1658. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  1659. {
  1660. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  1661. {
  1662. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1663. pInfo->result = ER_USERBREAK;
  1664. return 1; // 用户中断操作
  1665. }
  1666. }
  1667. }
  1668. }
  1669. else // 正向位图（top-down）
  1670. {
  1671. for (heigCount=0;heigCount<imgheight;heigCount++)
  1672. {
  1673. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1674. pDesPixAddr888  = (DWORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  1675. for (widthCount=0;widthCount<imgwidth;widthCount+=2)
  1676. {
  1677. pix = *pCurPixAddr++;
  1679. if ((imgwidth-widthCount)<2) // 结尾判断
  1680. j = imgwidth-widthCount;
  1681. else
  1682. j = 2;
  1684. for (i=0;i<j;i++)
  1685. {
  1686. if (i == 0)
  1687. *pDesPixAddr888++ = descol888[pix>>4];
  1688. else
  1689. *pDesPixAddr888++ = descol888[pix&0xf];
  1690. }
  1691. }
  1692. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  1693. {
  1694. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  1695. {
  1696. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1697. pInfo->result = ER_USERBREAK;
  1698. return 1; // 用户中断操作
  1699. }
  1700. }
  1701. }
  1702. }
  1703. }
  1704. break;
  1705. case DF_NULL:
  1706. default:
  1707. ASSERT(FALSE);
  1708. pInfo->result = ER_ILLCOMM;
  1709. return -1;
  1710. break;
  1711. }
  1712. return 0;
  1713. }
  1717. // 将4位RLE位图转换为指定的标准格式位图
  1718. // pInfo中的目标图像缓冲区必需已经被分配，且其中的源图像信息结构已被正确填写
  1719. // imgorg参数是源图像的扫描行次序标志：0-为倒向 1-为正向
  1720. int _from_4_RLE_read(LPINFOSTR pInfo, PBYTE lpSouData, int imgorg, RGBQUAD *lpPalette)
  1721. {
  1722. ASSERT(pInfo);
  1723. ASSERT(lpPalette); // 16色位图应有调色板
  1724. ASSERT(pInfo->state >= PKST_PASSINFO);
  1725. ASSERT(lpSouData);
  1726. ASSERT(imgorg == 0); // 压缩位图必需是倒向的
  1728. int imgheight = pInfo->imginfo.height; // 图像的高度
  1729. int imgwidth  = pInfo->imginfo.width; // 图像的宽度
  1730. PBYTE lpSou = lpSouData;
  1731. BYTE pix, pix2; // 当前值
  1732. int result, i;
  1734. BYTE **lppLineAddr = (BYTE**)::GlobalAlloc(GPTR, sizeof(PBYTE)*imgheight);
  1735. if (lppLineAddr == NULL)
  1736. {
  1737. pInfo->result = ER_MEMORYERR;
  1738. return -2; // 内存不足，返回
  1739. }
  1741. int linesize = ((imgwidth*4+31)/32)*4;
  1743. PBYTE lpDes = (PBYTE)::GlobalAlloc(GPTR, linesize*imgheight);
  1744. if (lpDes == NULL)
  1745. {
  1746. ::GlobalFree(lppLineAddr);
  1747. pInfo->result = ER_MEMORYERR;
  1748. return -2; // 内存不足，返回
  1749. }
  1751. // 初始化行地址数组
  1752. for (i=0;i<imgheight;i++)
  1753. lppLineAddr[i] = (PBYTE)(lpDes+linesize*i);
  1755. BOOL bEOF = FALSE; // 图像结尾标志
  1756. int  line = 0; // 当前行
  1758. _write2buff4RLE(0, 0, 0, lppLineAddr[line]); // 初始化写函数
  1760. // 先将RLE的数据解压成标准的BMP数据
  1761. while(!bEOF)
  1762. {
  1763. pix = *lpSou++;
  1765. if (pix == 0) // 绝对方式
  1766. {
  1767. pix2 = *lpSou++;
  1768. switch(pix2)
  1769. {
  1770. case 0: // 行结尾
  1771. line++;
  1772. _write2buff4RLE(2, 0, 0, lppLineAddr[line]);// 指定新的偏移地址
  1773. break;
  1774. case 1: // 图像结尾
  1775. bEOF = TRUE;
  1776. break;
  1777. case 2: // 当前地址偏移
  1778. pix = *lpSou++; pix2 = *lpSou++;
  1779. line += pix2; // 下移pix2行
  1780. _write2buff4RLE(2, pix%2, 0, (PBYTE)(lppLineAddr[line]+(DWORD)pix/2));
  1781. break;
  1782. default: // 不能压缩的像素
  1783. for (i=0;i<pix2/2;i++)
  1784. {
  1785. pix = *(lpSou+i);
  1786. _write2buff4RLE(1, 2, pix, NULL);
  1787. }
  1788. if (pix2%2)
  1789. { // 补充遗漏的单个像素
  1790. pix = *(lpSou+i);
  1791. _write2buff4RLE(1, 1, pix, NULL);
  1792. }
  1793. // (pix2+1)/2是将像素对齐到字节边界上，再加1、除2是对齐到字边界上
  1794. lpSou = (PBYTE)(lpSou + ((pix2+1)/2+1)/2*2); // 字对齐
  1795. break;
  1796. }
  1797. }
  1798. else // 编码方式
  1799. {
  1800. // pix == 相同像素的个数
  1801. pix2 = *lpSou++; // pix2 == 像素
  1802. _write2buff4RLE(1, (int)pix, pix2, NULL);
  1803. }
  1804. }
  1806. _write2buff4RLE(3, 0, 0, NULL); // 结束写函数
  1808. ::GlobalFree(lppLineAddr);
  1810. // 用标准4位转换函数转换到目标格式
  1811. result = _from_4_read(pInfo, lpDes, 0, lpPalette);
  1813. ::GlobalFree(lpDes);
  1815. return result;
  1816. }
  1820. // 将8位（即256色）位图转换为指定的标准格式位图
  1821. // pInfo中的目标图像缓冲区必需已经被分配，且其中的源图像信息结构已被正确填写
  1822. // imgorg参数是源图像的扫描行次序标志：0-为倒向 1-为正向
  1823. int _from_8_read(LPINFOSTR pInfo, PBYTE lpSou, int imgorg, RGBQUAD *lpPalette)
  1824. {
  1825. ASSERT(pInfo);
  1826. ASSERT(lpPalette); // 256色位图应有调色板
  1827. ASSERT(pInfo->state >= PKST_PASSINFO);
  1828. ASSERT(lpSou);
  1830. int imgheight = pInfo->imginfo.height; // 图像的高度
  1831. int imgwidth  = pInfo->imginfo.width; // 图像的宽度
  1832. int scansize  = pInfo->imginfo.linesize;// 每一扫描行的宽度(in byte)
  1833. ASSERT(pInfo->pImgInfo);
  1834. int palnum = ((BITMAPINFOHEADER*)(pInfo->pImgInfo))->biClrUsed;
  1835. int heigCount, widthCount, i, isou;
  1836. PBYTE pCurPixAddr;
  1837. BYTE pix; // 当前像素
  1839. palnum = (palnum == 0) ? 256:palnum; // 计算调色板项的实际个数
  1840. ASSERT(palnum <= 256);
  1842. switch(_get_desformat(pInfo)) // 标准图像格式（目标格式）
  1843. {
  1844. case DF_16_555:
  1845. {
  1846. // 以555位格式的调色板数据
  1847. WORD descol555[256];
  1848. for (i=0;i<palnum;i++) // 初始化色素颜色数据
  1849. descol555[i] = _cnv_rgb_to_555(lpPalette[i].rgbRed, lpPalette[i].rgbGreen, lpPalette[i].rgbBlue);
  1851. WORD *pDesPixAddr555;
  1853. if (imgorg == 0) // 源图是倒向位图
  1854. {
  1855. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  1856. {
  1857. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1858. pDesPixAddr555  = (WORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  1859. for (widthCount=0;widthCount<imgwidth;widthCount++)
  1860. *pDesPixAddr555++ = descol555[*pCurPixAddr++];
  1861. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  1862. {
  1863. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  1864. {
  1865. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1866. pInfo->result = ER_USERBREAK;
  1867. return 1; // 用户中断操作
  1868. }
  1869. }
  1870. }
  1871. }
  1872. else // 正向位图（top-down）
  1873. {
  1874. for (heigCount=0;heigCount<imgheight;heigCount++)
  1875. {
  1876. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1877. pDesPixAddr555  = (WORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  1878. for (widthCount=0;widthCount<imgwidth;widthCount++)
  1879. *pDesPixAddr555++ = descol555[*pCurPixAddr++];
  1880. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  1881. {
  1882. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  1883. {
  1884. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1885. pInfo->result = ER_USERBREAK;
  1886. return 1; // 用户中断操作
  1887. }
  1888. }
  1889. }
  1890. }
  1891. }
  1892. break;
  1893. case DF_16_565:
  1894. {
  1895. // 以565位格式的调色板数据
  1896. WORD descol565[256];
  1897. for (i=0;i<palnum;i++) // 初始化色素颜色数据
  1898. descol565[i] = _cnv_rgb_to_565(lpPalette[i].rgbRed, lpPalette[i].rgbGreen, lpPalette[i].rgbBlue);
  1900. WORD *pDesPixAddr565;
  1902. if (imgorg == 0) // 源图是倒向位图
  1903. {
  1904. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  1905. {
  1906. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1907. pDesPixAddr565  = (WORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  1908. for (widthCount=0;widthCount<imgwidth;widthCount++)
  1909. *pDesPixAddr565++ = descol565[*pCurPixAddr++];
  1910. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  1911. {
  1912. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  1913. {
  1914. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1915. pInfo->result = ER_USERBREAK;
  1916. return 1; // 用户中断操作
  1917. }
  1918. }
  1919. }
  1920. }
  1921. else // 正向位图（top-down）
  1922. {
  1923. for (heigCount=0;heigCount<imgheight;heigCount++)
  1924. {
  1925. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1926. pDesPixAddr565  = (WORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  1927. for (widthCount=0;widthCount<imgwidth;widthCount++)
  1928. *pDesPixAddr565++ = descol565[*pCurPixAddr++];
  1929. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  1930. {
  1931. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  1932. {
  1933. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1934. pInfo->result = ER_USERBREAK;
  1935. return 1; // 用户中断操作
  1936. }
  1937. }
  1938. }
  1939. }
  1940. }
  1941. break;
  1942. case DF_24:
  1943. {
  1944. PBYTE pDesPixAddr24;
  1945. if (imgorg  == 0) // 源图是倒向位图
  1946. {
  1947. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  1948. {
  1949. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1950. pDesPixAddr24  = (PBYTE)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  1951. for (widthCount=0;widthCount<imgwidth;widthCount++)
  1952. {
  1953. pix = *pCurPixAddr++;
  1954. *pDesPixAddr24++ = lpPalette[pix].rgbBlue;
  1955. *pDesPixAddr24++ = lpPalette[pix].rgbGreen;
  1956. *pDesPixAddr24++ = lpPalette[pix].rgbRed;
  1957. }
  1958. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  1959. {
  1960. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  1961. {
  1962. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1963. pInfo->result = ER_USERBREAK;
  1964. return 1; // 用户中断操作
  1965. }
  1966. }
  1967. }
  1968. }
  1969. else // 正向位图（top-down）
  1970. {
  1971. for (heigCount=0;heigCount<imgheight;heigCount++)
  1972. {
  1973. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  1974. pDesPixAddr24  = (PBYTE)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  1975. for (widthCount=0;widthCount<imgwidth;widthCount++)
  1976. {
  1977. pix = *pCurPixAddr++;
  1978. *pDesPixAddr24++ = lpPalette[pix].rgbBlue;
  1979. *pDesPixAddr24++ = lpPalette[pix].rgbGreen;
  1980. *pDesPixAddr24++ = lpPalette[pix].rgbRed;
  1981. }
  1982. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  1983. {
  1984. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  1985. {
  1986. // 如果进度函数返回1，则说明用户想中断操作，返回。
  1987. pInfo->result = ER_USERBREAK;
  1988. return 1; // 用户中断操作
  1989. }
  1990. }
  1991. }
  1992. }
  1993. }
  1994. break;
  1995. case DF_32:
  1996. {
  1997. // 以888位格式的调色板数据
  1998. DWORD descol888[256];
  1999. for (i=0;i<palnum;i++) // 初始化色素颜色数据
  2000. descol888[i] = _cnv_rgb_to_888(lpPalette[i].rgbRed, lpPalette[i].rgbGreen, lpPalette[i].rgbBlue);
  2002. DWORD *pDesPixAddr888;
  2004. if (imgorg == 0) // 源图是倒向位图
  2005. {
  2006. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  2007. {
  2008. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2009. pDesPixAddr888  = (DWORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  2010. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2011. *pDesPixAddr888++ = descol888[*pCurPixAddr++];
  2012. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  2013. {
  2014. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  2015. {
  2016. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2017. pInfo->result = ER_USERBREAK;
  2018. return 1; // 用户中断操作
  2019. }
  2020. }
  2021. }
  2022. }
  2023. else // 正向位图（top-down）
  2024. {
  2025. for (heigCount=0;heigCount<imgheight;heigCount++)
  2026. {
  2027. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2028. pDesPixAddr888  = (DWORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  2029. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2030. *pDesPixAddr888++ = descol888[*pCurPixAddr++];
  2031. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  2032. {
  2033. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  2034. {
  2035. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2036. pInfo->result = ER_USERBREAK;
  2037. return 1; // 用户中断操作
  2038. }
  2039. }
  2040. }
  2041. }
  2042. }
  2043. break;
  2044. case DF_NULL:
  2045. default:
  2046. ASSERT(FALSE);
  2047. pInfo->result = ER_ILLCOMM;
  2048. return -1;
  2049. break;
  2050. }
  2051. return 0;
  2052. }
  2057. // 将8位RLE位图转换为指定的标准格式位图
  2058. // pInfo中的目标图像缓冲区必需已经被分配，且其中的源图像信息结构已被正确填写
  2059. // imgorg参数是源图像的扫描行次序标志：0-为倒向 1-为正向
  2060. int _from_8_RLE_read(LPINFOSTR pInfo, PBYTE lpSouData, int imgorg, RGBQUAD *lpPalette)
  2061. {
  2062. ASSERT(pInfo);
  2063. ASSERT(lpPalette); // 256色位图应有调色板
  2064. ASSERT(pInfo->state >= PKST_PASSINFO);
  2065. ASSERT(lpSouData);
  2066. ASSERT(imgorg == 0); // 压缩位图必需是倒向的
  2068. int imgheight = pInfo->imginfo.height; // 图像的高度
  2069. int imgwidth  = pInfo->imginfo.width; // 图像的宽度
  2070. PBYTE lpSou = lpSouData;
  2071. BYTE pix, pix2; // 当前值
  2072. int result, i;
  2074. BYTE **lppLineAddr = (BYTE**)::GlobalAlloc(GPTR, sizeof(PBYTE)*imgheight);
  2075. if (lppLineAddr == NULL)
  2076. {
  2077. pInfo->result = ER_MEMORYERR;
  2078. return -2; // 内存不足，返回
  2079. }
  2081. int linesize = ((imgwidth+3)/4)*4; // 扫描行尺寸(in byte)
  2083. PBYTE lpDes = (PBYTE)::GlobalAlloc(GPTR, linesize*imgheight);
  2084. if (lpDes == NULL)
  2085. {
  2086. ::GlobalFree(lppLineAddr);
  2087. pInfo->result = ER_MEMORYERR;
  2088. return -2; // 内存不足，返回
  2089. }
  2091. // 初始化行地址数组
  2092. for (i=0;i<imgheight;i++)
  2093. lppLineAddr[i] = (PBYTE)(lpDes+linesize*i);
  2095. BOOL bEOF = FALSE; // 图像结尾标志
  2096. int  line = 0; // 当前行
  2098. _write2buff8RLE(0, 0, 0, lppLineAddr[line]); // 初始化写函数
  2100. while(!bEOF)
  2101. {
  2102. pix = *lpSou++;
  2104. if (pix == 0) // 绝对方式
  2105. {
  2106. pix2 = *lpSou++;
  2107. switch(pix2)
  2108. {
  2109. case 0: // 行结尾
  2110. line++;
  2111. _write2buff8RLE(2, 0, 0, lppLineAddr[line]);// 指定新的偏移地址
  2112. break;
  2113. case 1: // 图像结尾
  2114. bEOF = TRUE;
  2115. break;
  2116. case 2: // 当前地址偏移
  2117. pix = *lpSou++; pix2 = *lpSou++;
  2118. line += pix2; // 下移pix2行
  2119. _write2buff8RLE(2, 0, 0, (PBYTE)(lppLineAddr[line]+(DWORD)pix));
  2120. break;
  2121. default: // 不能压缩的像素
  2122. for (i=0;i<pix2;i++)
  2123. {
  2124. pix = *(lpSou+i);
  2125. _write2buff8RLE(1, 1, pix, NULL);
  2126. }
  2127. // (pix2+1)/2是将像素对齐到字节边界上，再加1、除2是对齐到字边界上
  2128. lpSou = (PBYTE)(lpSou + ((pix2+1)/2)*2); // 字对齐
  2129. break;
  2130. }
  2131. }
  2132. else // 编码方式
  2133. {
  2134. // pix == 相同像素的个数
  2135. pix2 = *lpSou++; // pix2 == 像素
  2136. _write2buff8RLE(1, (int)pix, pix2, NULL);
  2137. }
  2138. }
  2140. _write2buff8RLE(3, 0, 0, NULL); // 结束写函数
  2142. ::GlobalFree(lppLineAddr);
  2144. // 用标准8位转换函数转换到目标格式
  2145. result = _from_8_read(pInfo, lpDes, 0, lpPalette);
  2147. ::GlobalFree(lpDes);
  2149. return result;
  2150. }
  2155. // 将16位555位图转换为指定的标准格式位图
  2156. // pInfo中的目标图像缓冲区必需已经被分配，且其中的源图像信息结构已被正确填写
  2157. // imgorg参数是源图像的扫描行次序标志：0-为倒向 1-为正向
  2158. int _from_16_555_read(LPINFOSTR pInfo, PBYTE lpSou, int imgorg)
  2159. {
  2160. ASSERT(pInfo);
  2161. ASSERT(pInfo->state >= PKST_PASSINFO);
  2162. ASSERT(lpSou);
  2164. int imgheight = pInfo->imginfo.height; // 图像的高度
  2165. int imgwidth  = pInfo->imginfo.width; // 图像的宽度
  2166. int scansize  = pInfo->imginfo.linesize;// 每一扫描行的宽度(in byte)
  2167. int heigCount, widthCount, isou;
  2168. WORD *pCurPixAddr;
  2169. WORD pix; // 当前像素
  2171. switch(_get_desformat(pInfo)) // 标准图像格式（目标格式）
  2172. {
  2173. case DF_16_555:
  2174. {
  2175. WORD *pDesPixAddr555;
  2176. if (imgorg == 0) // 源图是倒向位图
  2177. {
  2178. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  2179. {
  2180. pCurPixAddr  = (WORD*)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2181. pDesPixAddr555  = (WORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  2182. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2183. *pDesPixAddr555++ = *pCurPixAddr++;
  2184. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  2185. {
  2186. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  2187. {
  2188. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2189. pInfo->result = ER_USERBREAK;
  2190. return 1; // 用户中断操作
  2191. }
  2192. }
  2193. }
  2194. }
  2195. else // 正向位图（top-down）
  2196. {
  2197. for (heigCount=0;heigCount<imgheight;heigCount++)
  2198. {
  2199. pCurPixAddr  = (WORD*)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2200. pDesPixAddr555  = (WORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  2201. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2202. *pDesPixAddr555++ = *pCurPixAddr++;
  2203. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  2204. {
  2205. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  2206. {
  2207. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2208. pInfo->result = ER_USERBREAK;
  2209. return 1; // 用户中断操作
  2210. }
  2211. }
  2212. }
  2213. }
  2214. }
  2215. break;
  2216. case DF_16_565:
  2217. {
  2218. WORD *pDesPixAddr565;
  2219. if (imgorg == 0) // 源图是倒向位图
  2220. {
  2221. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  2222. {
  2223. pCurPixAddr  = (WORD*)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2224. pDesPixAddr565  = (WORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  2225. for (widthCount=0;widthCount<imgwidth;widthCount++) // 实现从555到565的转换
  2226. *pDesPixAddr565++ = (((*pCurPixAddr)&0xffe0)<<1)|((*pCurPixAddr++)&0x1f);
  2227. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  2228. {
  2229. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  2230. {
  2231. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2232. pInfo->result = ER_USERBREAK;
  2233. return 1; // 用户中断操作
  2234. }
  2235. }
  2236. }
  2237. }
  2238. else // 正向位图（top-down）
  2239. {
  2240. for (heigCount=0;heigCount<imgheight;heigCount++)
  2241. {
  2242. pCurPixAddr  = (WORD*)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2243. pDesPixAddr565  = (WORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  2244. for (widthCount=0;widthCount<imgwidth;widthCount++) // 实现从555到565的转换
  2245. *pDesPixAddr565++ = (((*pCurPixAddr)&0xffe0)<<1)|((*pCurPixAddr++)&0x1f);
  2246. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  2247. {
  2248. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  2249. {
  2250. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2251. pInfo->result = ER_USERBREAK;
  2252. return 1; // 用户中断操作
  2253. }
  2254. }
  2255. }
  2256. }
  2257. }
  2258. break;
  2259. case DF_24:
  2260. {
  2261. PBYTE pDesPixAddr24;
  2262. BYTE  red, green, blue;
  2264. if (imgorg  == 0) // 源图是倒向位图
  2265. {
  2266. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  2267. {
  2268. pCurPixAddr  = (WORD*)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2269. pDesPixAddr24  = (PBYTE)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  2270. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2271. {
  2272. pix = *pCurPixAddr++;
  2273. _cnv_555_to_rgb(pix, &red, &green, &blue);
  2274. *pDesPixAddr24++ = blue;
  2275. *pDesPixAddr24++ = green;
  2276. *pDesPixAddr24++ = red;
  2277. }
  2278. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  2279. {
  2280. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  2281. {
  2282. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2283. pInfo->result = ER_USERBREAK;
  2284. return 1; // 用户中断操作
  2285. }
  2286. }
  2287. }
  2288. }
  2289. else // 正向位图（top-down）
  2290. {
  2291. for (heigCount=0;heigCount<imgheight;heigCount++)
  2292. {
  2293. pCurPixAddr  = (WORD*)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2294. pDesPixAddr24  = (PBYTE)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  2295. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2296. {
  2297. pix = *pCurPixAddr++;
  2298. _cnv_555_to_rgb(pix, &red, &green, &blue);
  2299. *pDesPixAddr24++ = blue;
  2300. *pDesPixAddr24++ = green;
  2301. *pDesPixAddr24++ = red;
  2302. }
  2303. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  2304. {
  2305. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  2306. {
  2307. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2308. pInfo->result = ER_USERBREAK;
  2309. return 1; // 用户中断操作
  2310. }
  2311. }
  2312. }
  2313. }
  2314. }
  2315. break;
  2316. case DF_32:
  2317. {
  2318. DWORD *pDesPixAddr888;
  2319. DWORD pix32;
  2321. if (imgorg == 0) // 源图是倒向位图
  2322. {
  2323. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  2324. {
  2325. pCurPixAddr  = (WORD*)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2326. pDesPixAddr888  = (DWORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  2327. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2328. {
  2329. pix32 = (DWORD)*pCurPixAddr++; // 实现555到888的转换
  2330. *pDesPixAddr888++ = ((pix32<<3)&0xf8)|((pix32<<6)&0xf800)|((pix32<<9)&0xf80000);
  2331. }
  2332. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  2333. {
  2334. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  2335. {
  2336. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2337. pInfo->result = ER_USERBREAK;
  2338. return 1; // 用户中断操作
  2339. }
  2340. }
  2341. }
  2342. }
  2343. else // 正向位图（top-down）
  2344. {
  2345. for (heigCount=0;heigCount<imgheight;heigCount++)
  2346. {
  2347. pCurPixAddr  = (WORD*)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2348. pDesPixAddr888  = (DWORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  2349. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2350. {
  2351. pix32 = (DWORD)*pCurPixAddr++; // 实现555到888的转换
  2352. *pDesPixAddr888++ = ((pix32<<3)&0xf8)|((pix32<<6)&0xf800)|((pix32<<9)&0xf80000);
  2353. }
  2354. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  2355. {
  2356. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  2357. {
  2358. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2359. pInfo->result = ER_USERBREAK;
  2360. return 1; // 用户中断操作
  2361. }
  2362. }
  2363. }
  2364. }
  2365. }
  2366. break;
  2367. case DF_NULL:
  2368. default:
  2369. ASSERT(FALSE);
  2370. pInfo->result = ER_ILLCOMM;
  2371. return -1;
  2372. break;
  2373. }
  2374. return 0;
  2375. }
  2380. // 将16位565位图转换为指定的标准格式位图
  2381. // pInfo中的目标图像缓冲区必需已经被分配，且其中的源图像信息结构已被正确填写
  2382. // imgorg参数是源图像的扫描行次序标志：0-为倒向 1-为正向
  2383. int _from_16_565_read(LPINFOSTR pInfo, PBYTE lpSou, int imgorg)
  2384. {
  2385. ASSERT(pInfo);
  2386. ASSERT(pInfo->state >= PKST_PASSINFO);
  2387. ASSERT(lpSou);
  2389. int imgheight = pInfo->imginfo.height; // 图像的高度
  2390. int imgwidth  = pInfo->imginfo.width; // 图像的宽度
  2391. int scansize  = pInfo->imginfo.linesize;// 每一扫描行的宽度(in byte)
  2392. int heigCount, widthCount, isou;
  2393. WORD *pCurPixAddr;
  2394. WORD pix; // 当前像素
  2396. switch(_get_desformat(pInfo)) // 标准图像格式（目标格式）
  2397. {
  2398. case DF_16_555:
  2399. {
  2400. WORD *pDesPixAddr555;
  2401. if (imgorg == 0) // 源图是倒向位图
  2402. {
  2403. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  2404. {
  2405. pCurPixAddr  = (WORD*)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2406. pDesPixAddr555  = (WORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  2407. for (widthCount=0;widthCount<imgwidth;widthCount++) // 实现从565到555的转换
  2408. *pDesPixAddr555++ = (((*pCurPixAddr)>>1)&0x7fe0)|((*pCurPixAddr++)&0x1f);
  2409. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  2410. {
  2411. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  2412. {
  2413. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2414. pInfo->result = ER_USERBREAK;
  2415. return 1; // 用户中断操作
  2416. }
  2417. }
  2418. }
  2419. }
  2420. else // 正向位图（top-down）
  2421. {
  2422. for (heigCount=0;heigCount<imgheight;heigCount++)
  2423. {
  2424. pCurPixAddr  = (WORD*)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2425. pDesPixAddr555  = (WORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  2426. for (widthCount=0;widthCount<imgwidth;widthCount++) // 实现从565到555的转换
  2427. *pDesPixAddr555++ = (((*pCurPixAddr)>>1)&0x7fe0)|((*pCurPixAddr++)&0x1f);
  2428. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  2429. {
  2430. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  2431. {
  2432. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2433. pInfo->result = ER_USERBREAK;
  2434. return 1; // 用户中断操作
  2435. }
  2436. }
  2437. }
  2438. }
  2439. }
  2440. break;
  2441. case DF_16_565:
  2442. {
  2443. WORD *pDesPixAddr565;
  2444. if (imgorg == 0) // 源图是倒向位图
  2445. {
  2446. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  2447. {
  2448. pCurPixAddr  = (WORD*)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2449. pDesPixAddr565  = (WORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  2450. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2451. *pDesPixAddr565++ = *pCurPixAddr++;
  2452. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  2453. {
  2454. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  2455. {
  2456. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2457. pInfo->result = ER_USERBREAK;
  2458. return 1; // 用户中断操作
  2459. }
  2460. }
  2461. }
  2462. }
  2463. else // 正向位图（top-down）
  2464. {
  2465. for (heigCount=0;heigCount<imgheight;heigCount++)
  2466. {
  2467. pCurPixAddr  = (WORD*)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2468. pDesPixAddr565  = (WORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  2469. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2470. *pDesPixAddr565++ = *pCurPixAddr++;
  2471. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  2472. {
  2473. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  2474. {
  2475. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2476. pInfo->result = ER_USERBREAK;
  2477. return 1; // 用户中断操作
  2478. }
  2479. }
  2480. }
  2481. }
  2482. }
  2483. break;
  2484. case DF_24:
  2485. {
  2486. PBYTE pDesPixAddr24;
  2487. BYTE  red, green, blue;
  2489. if (imgorg  == 0) // 源图是倒向位图
  2490. {
  2491. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  2492. {
  2493. pCurPixAddr  = (WORD*)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2494. pDesPixAddr24  = (PBYTE)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  2495. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2496. {
  2497. pix = *pCurPixAddr++;
  2498. _cnv_565_to_rgb(pix, &red, &green, &blue);
  2499. *pDesPixAddr24++ = blue;
  2500. *pDesPixAddr24++ = green;
  2501. *pDesPixAddr24++ = red;
  2502. }
  2503. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  2504. {
  2505. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  2506. {
  2507. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2508. pInfo->result = ER_USERBREAK;
  2509. return 1; // 用户中断操作
  2510. }
  2511. }
  2512. }
  2513. }
  2514. else // 正向位图（top-down）
  2515. {
  2516. for (heigCount=0;heigCount<imgheight;heigCount++)
  2517. {
  2518. pCurPixAddr  = (WORD*)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2519. pDesPixAddr24  = (PBYTE)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  2520. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2521. {
  2522. pix = *pCurPixAddr++;
  2523. _cnv_565_to_rgb(pix, &red, &green, &blue);
  2524. *pDesPixAddr24++ = blue;
  2525. *pDesPixAddr24++ = green;
  2526. *pDesPixAddr24++ = red;
  2527. }
  2528. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  2529. {
  2530. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  2531. {
  2532. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2533. pInfo->result = ER_USERBREAK;
  2534. return 1; // 用户中断操作
  2535. }
  2536. }
  2537. }
  2538. }
  2539. }
  2540. break;
  2541. case DF_32:
  2542. {
  2543. DWORD *pDesPixAddr888;
  2544. DWORD pix32;
  2546. if (imgorg == 0) // 源图是倒向位图
  2547. {
  2548. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  2549. {
  2550. pCurPixAddr  = (WORD*)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2551. pDesPixAddr888  = (DWORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  2552. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2553. {
  2554. pix32 = (DWORD)*pCurPixAddr++; // 实现565到888的转换
  2555. *pDesPixAddr888++ = ((pix32<<3)&0xf8)|((pix32<<5)&0xfc00)|((pix32<<8)&0xf80000);
  2556. }
  2557. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  2558. {
  2559. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  2560. {
  2561. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2562. pInfo->result = ER_USERBREAK;
  2563. return 1; // 用户中断操作
  2564. }
  2565. }
  2566. }
  2567. }
  2568. else // 正向位图（top-down）
  2569. {
  2570. for (heigCount=0;heigCount<imgheight;heigCount++)
  2571. {
  2572. pCurPixAddr  = (WORD*)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2573. pDesPixAddr888  = (DWORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  2574. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2575. {
  2576. pix32 = (DWORD)*pCurPixAddr++; // 实现565到888的转换
  2577. *pDesPixAddr888++ = ((pix32<<3)&0xf8)|((pix32<<5)&0xfc00)|((pix32<<8)&0xf80000);
  2578. }
  2579. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  2580. {
  2581. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  2582. {
  2583. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2584. pInfo->result = ER_USERBREAK;
  2585. return 1; // 用户中断操作
  2586. }
  2587. }
  2588. }
  2589. }
  2590. }
  2591. break;
  2592. case DF_NULL:
  2593. default:
  2594. ASSERT(FALSE);
  2595. pInfo->result = ER_ILLCOMM;
  2596. return -1;
  2597. break;
  2598. }
  2599. return 0;
  2600. }
  2604. // 将24位位图转换为指定的标准格式位图
  2605. // pInfo中的目标图像缓冲区必需已经被分配，且其中的源图像信息结构已被正确填写
  2606. // imgorg参数是源图像的扫描行次序标志：0-为倒向 1-为正向
  2607. int _from_24_read(LPINFOSTR pInfo, PBYTE lpSou, int imgorg)
  2608. {
  2609. ASSERT(pInfo);
  2610. ASSERT(pInfo->state >= PKST_PASSINFO);
  2611. ASSERT(lpSou);
  2613. int imgheight = pInfo->imginfo.height; // 图像的高度
  2614. int imgwidth  = pInfo->imginfo.width; // 图像的宽度
  2615. int scansize  = pInfo->imginfo.linesize;// 每一扫描行的宽度(in byte)
  2616. int heigCount, widthCount, isou;
  2617. PBYTE pCurPixAddr;
  2618. BYTE  red, green, blue;
  2620. switch(_get_desformat(pInfo)) // 标准图像格式（目标格式）
  2621. {
  2622. case DF_16_555:
  2623. {
  2624. WORD *pDesPixAddr555;
  2625. if (imgorg == 0) // 源图是倒向位图
  2626. {
  2627. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  2628. {
  2629. pCurPixAddr = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2630. pDesPixAddr555  = (WORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  2631. for (widthCount=0;widthCount<imgwidth;widthCount++) // 实现从24到555的转换
  2632. {
  2633. blue = *pCurPixAddr++; green = *pCurPixAddr++; red = *pCurPixAddr++;
  2634. *pDesPixAddr555++ = _cnv_rgb_to_555(red, green, blue);
  2635. }
  2636. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  2637. {
  2638. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  2639. {
  2640. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2641. pInfo->result = ER_USERBREAK;
  2642. return 1; // 用户中断操作
  2643. }
  2644. }
  2645. }
  2646. }
  2647. else // 正向位图（top-down）
  2648. {
  2649. for (heigCount=0;heigCount<imgheight;heigCount++)
  2650. {
  2651. pCurPixAddr = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2652. pDesPixAddr555  = (WORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  2653. for (widthCount=0;widthCount<imgwidth;widthCount++) // 实现从24到555的转换
  2654. {
  2655. blue = *pCurPixAddr++; green = *pCurPixAddr++; red = *pCurPixAddr++;
  2656. *pDesPixAddr555++ = _cnv_rgb_to_555(red, green, blue);
  2657. }
  2658. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  2659. {
  2660. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  2661. {
  2662. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2663. pInfo->result = ER_USERBREAK;
  2664. return 1; // 用户中断操作
  2665. }
  2666. }
  2667. }
  2668. }
  2669. }
  2670. break;
  2671. case DF_16_565:
  2672. {
  2673. WORD *pDesPixAddr565;
  2674. if (imgorg == 0) // 源图是倒向位图
  2675. {
  2676. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  2677. {
  2678. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2679. pDesPixAddr565  = (WORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  2680. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2681. {
  2682. blue = *pCurPixAddr++; green = *pCurPixAddr++; red = *pCurPixAddr++;
  2683. *pDesPixAddr565++ = _cnv_rgb_to_565(red, green, blue);
  2684. }
  2685. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  2686. {
  2687. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  2688. {
  2689. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2690. pInfo->result = ER_USERBREAK;
  2691. return 1; // 用户中断操作
  2692. }
  2693. }
  2694. }
  2695. }
  2696. else // 正向位图（top-down）
  2697. {
  2698. for (heigCount=0;heigCount<imgheight;heigCount++)
  2699. {
  2700. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2701. pDesPixAddr565  = (WORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  2702. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2703. {
  2704. blue = *pCurPixAddr++; green = *pCurPixAddr++; red = *pCurPixAddr++;
  2705. *pDesPixAddr565++ = _cnv_rgb_to_565(red, green, blue);
  2706. }
  2707. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  2708. {
  2709. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  2710. {
  2711. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2712. pInfo->result = ER_USERBREAK;
  2713. return 1; // 用户中断操作
  2714. }
  2715. }
  2716. }
  2717. }
  2718. }
  2719. break;
  2720. case DF_24:
  2721. {
  2722. PBYTE pDesPixAddr24;
  2723. if (imgorg  == 0) // 源图是倒向位图
  2724. {
  2725. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  2726. {
  2727. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2728. pDesPixAddr24  = (PBYTE)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  2729. ::CopyMemory((PVOID)pDesPixAddr24, (PVOID)pCurPixAddr, imgwidth*3);
  2730. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  2731. {
  2732. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  2733. {
  2734. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2735. pInfo->result = ER_USERBREAK;
  2736. return 1; // 用户中断操作
  2737. }
  2738. }
  2739. }
  2740. }
  2741. else // 正向位图（top-down）
  2742. {
  2743. for (heigCount=0;heigCount<imgheight;heigCount++)
  2744. {
  2745. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2746. pDesPixAddr24  = (PBYTE)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  2747. ::CopyMemory((PVOID)pDesPixAddr24, (PVOID)pCurPixAddr, imgwidth*3);
  2748. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  2749. {
  2750. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  2751. {
  2752. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2753. pInfo->result = ER_USERBREAK;
  2754. return 1; // 用户中断操作
  2755. }
  2756. }
  2757. }
  2758. }
  2759. }
  2760. break;
  2761. case DF_32:
  2762. {
  2763. DWORD *pDesPixAddr888;
  2764. DWORD pix32;
  2766. if (imgorg == 0) // 源图是倒向位图
  2767. {
  2768. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  2769. {
  2770. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2771. pDesPixAddr888  = (DWORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  2772. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2773. {
  2774. pix32 = *((DWORD*)pCurPixAddr);
  2775. pix32 &= 0xffffff; // 888格式，舍弃最高位
  2776. pCurPixAddr += 3;
  2777. *pDesPixAddr888++ = pix32;
  2778. }
  2779. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  2780. {
  2781. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  2782. {
  2783. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2784. pInfo->result = ER_USERBREAK;
  2785. return 1; // 用户中断操作
  2786. }
  2787. }
  2788. }
  2789. }
  2790. else // 正向位图（top-down）
  2791. {
  2792. for (heigCount=0;heigCount<imgheight;heigCount++)
  2793. {
  2794. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2795. pDesPixAddr888  = (DWORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  2796. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2797. {
  2798. pix32 = *((DWORD*)pCurPixAddr);
  2799. pix32 &= 0xffffff; // 888格式，舍弃最高位
  2800. pCurPixAddr += 3;
  2801. *pDesPixAddr888++ = pix32;
  2802. }
  2803. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  2804. {
  2805. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  2806. {
  2807. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2808. pInfo->result = ER_USERBREAK;
  2809. return 1; // 用户中断操作
  2810. }
  2811. }
  2812. }
  2813. }
  2814. }
  2815. break;
  2816. case DF_NULL:
  2817. default:
  2818. ASSERT(FALSE);
  2819. pInfo->result = ER_ILLCOMM;
  2820. return -1;
  2821. break;
  2822. }
  2823. return 0;
  2824. }
  2828. // 将32位位图转换为指定的标准格式位图
  2829. // pInfo中的目标图像缓冲区必需已经被分配，且其中的源图像信息结构已被正确填写
  2830. // imgorg参数是源图像的扫描行次序标志：0-为倒向 1-为正向
  2831. int _from_32_read(LPINFOSTR pInfo, PBYTE lpSou, int imgorg)
  2832. {
  2833. ASSERT(pInfo);
  2834. ASSERT(pInfo->state >= PKST_PASSINFO);
  2835. ASSERT(lpSou);
  2837. int imgheight = pInfo->imginfo.height; // 图像的高度
  2838. int imgwidth  = pInfo->imginfo.width; // 图像的宽度
  2839. int scansize  = pInfo->imginfo.linesize;// 每一扫描行的宽度(in byte)
  2840. int heigCount, widthCount, isou;
  2841. PBYTE pCurPixAddr;
  2842. BYTE  red, green, blue;
  2844. switch(_get_desformat(pInfo)) // 标准图像格式（目标格式）
  2845. {
  2846. case DF_16_555:
  2847. {
  2848. WORD *pDesPixAddr555;
  2849. if (imgorg == 0) // 源图是倒向位图
  2850. {
  2851. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  2852. {
  2853. pCurPixAddr = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2854. pDesPixAddr555  = (WORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  2855. for (widthCount=0;widthCount<imgwidth;widthCount++) // 实现从24到555的转换
  2856. {
  2857. blue = *pCurPixAddr++; green = *pCurPixAddr++; red = *pCurPixAddr++;
  2858. pCurPixAddr++; // 舍弃最高位
  2859. *pDesPixAddr555++ = _cnv_rgb_to_555(red, green, blue);
  2860. }
  2861. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  2862. {
  2863. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  2864. {
  2865. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2866. pInfo->result = ER_USERBREAK;
  2867. return 1; // 用户中断操作
  2868. }
  2869. }
  2870. }
  2871. }
  2872. else // 正向位图（top-down）
  2873. {
  2874. for (heigCount=0;heigCount<imgheight;heigCount++)
  2875. {
  2876. pCurPixAddr = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2877. pDesPixAddr555  = (WORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  2878. for (widthCount=0;widthCount<imgwidth;widthCount++) // 实现从24到555的转换
  2879. {
  2880. blue = *pCurPixAddr++; green = *pCurPixAddr++; red = *pCurPixAddr++;
  2881. pCurPixAddr++; // 舍弃最高位
  2882. *pDesPixAddr555++ = _cnv_rgb_to_555(red, green, blue);
  2883. }
  2884. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  2885. {
  2886. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  2887. {
  2888. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2889. pInfo->result = ER_USERBREAK;
  2890. return 1; // 用户中断操作
  2891. }
  2892. }
  2893. }
  2894. }
  2895. }
  2896. break;
  2897. case DF_16_565:
  2898. {
  2899. WORD *pDesPixAddr565;
  2900. if (imgorg == 0) // 源图是倒向位图
  2901. {
  2902. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  2903. {
  2904. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2905. pDesPixAddr565  = (WORD*)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  2906. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2907. {
  2908. blue = *pCurPixAddr++; green = *pCurPixAddr++; red = *pCurPixAddr++;
  2909. *pCurPixAddr++;
  2910. *pDesPixAddr565++ = _cnv_rgb_to_565(red, green, blue);
  2911. }
  2912. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  2913. {
  2914. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  2915. {
  2916. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2917. pInfo->result = ER_USERBREAK;
  2918. return 1; // 用户中断操作
  2919. }
  2920. }
  2921. }
  2922. }
  2923. else // 正向位图（top-down）
  2924. {
  2925. for (heigCount=0;heigCount<imgheight;heigCount++)
  2926. {
  2927. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2928. pDesPixAddr565  = (WORD*)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  2929. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2930. {
  2931. blue = *pCurPixAddr++; green = *pCurPixAddr++; red = *pCurPixAddr++;
  2932. *pCurPixAddr++;
  2933. *pDesPixAddr565++ = _cnv_rgb_to_565(red, green, blue);
  2934. }
  2935. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  2936. {
  2937. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  2938. {
  2939. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2940. pInfo->result = ER_USERBREAK;
  2941. return 1; // 用户中断操作
  2942. }
  2943. }
  2944. }
  2945. }
  2946. }
  2947. break;
  2948. case DF_24:
  2949. {
  2950. PBYTE pDesPixAddr24;
  2951. if (imgorg  == 0) // 源图是倒向位图
  2952. {
  2953. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  2954. {
  2955. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2956. pDesPixAddr24  = (PBYTE)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  2957. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2958. {
  2959. *pDesPixAddr24++ = *pCurPixAddr++;
  2960. *pDesPixAddr24++ = *pCurPixAddr++;
  2961. *pDesPixAddr24++ = *pCurPixAddr++;
  2962. *pCurPixAddr++;
  2963. }
  2964. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  2965. {
  2966. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  2967. {
  2968. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2969. pInfo->result = ER_USERBREAK;
  2970. return 1; // 用户中断操作
  2971. }
  2972. }
  2973. }
  2974. }
  2975. else // 正向位图（top-down）
  2976. {
  2977. for (heigCount=0;heigCount<imgheight;heigCount++)
  2978. {
  2979. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  2980. pDesPixAddr24  = (PBYTE)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  2981. for (widthCount=0;widthCount<imgwidth;widthCount++)
  2982. {
  2983. *pDesPixAddr24++ = *pCurPixAddr++;
  2984. *pDesPixAddr24++ = *pCurPixAddr++;
  2985. *pDesPixAddr24++ = *pCurPixAddr++;
  2986. *pCurPixAddr++;
  2987. }
  2988. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  2989. {
  2990. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  2991. {
  2992. // 如果进度函数返回1，则说明用户想中断操作，返回。
  2993. pInfo->result = ER_USERBREAK;
  2994. return 1; // 用户中断操作
  2995. }
  2996. }
  2997. }
  2998. }
  2999. }
  3000. break;
  3001. case DF_32:
  3002. {
  3003. PBYTE pDesPixAddr888;
  3004. if (imgorg == 0) // 源图是倒向位图
  3005. {
  3006. for (heigCount=imgheight-1, isou=0;heigCount>=0;heigCount--, isou++)
  3007. {
  3008. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  3009. pDesPixAddr888  = (PBYTE)pInfo->pLineAddr[isou];// 目标缓冲区当前行第一个像素的地址
  3010. ::CopyMemory((PVOID)pDesPixAddr888, (PVOID)pCurPixAddr, imgwidth*4);
  3011. if ((pInfo->fpProgress)&&(!(isou%RWPROGRESSSTEP)))
  3012. {
  3013. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, isou))
  3014. {
  3015. // 如果进度函数返回1，则说明用户想中断操作，返回。
  3016. pInfo->result = ER_USERBREAK;
  3017. return 1; // 用户中断操作
  3018. }
  3019. }
  3020. }
  3021. }
  3022. else // 正向位图（top-down）
  3023. {
  3024. for (heigCount=0;heigCount<imgheight;heigCount++)
  3025. {
  3026. pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  3027. pDesPixAddr888  = (PBYTE)pInfo->pLineAddr[heigCount];// 目标缓冲区当前行第一个像素的地址
  3028. ::CopyMemory((PVOID)pDesPixAddr888, (PVOID)pCurPixAddr, imgwidth*4);
  3029. if ((pInfo->fpProgress)&&(!(heigCount%RWPROGRESSSTEP)))
  3030. {
  3031. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, heigCount))
  3032. {
  3033. // 如果进度函数返回1，则说明用户想中断操作，返回。
  3034. pInfo->result = ER_USERBREAK;
  3035. return 1; // 用户中断操作
  3036. }
  3037. }
  3038. }
  3039. }
  3040. }
  3041. break;
  3042. case DF_NULL:
  3043. default:
  3044. ASSERT(FALSE);
  3045. pInfo->result = ER_ILLCOMM;
  3046. return -1;
  3047. break;
  3048. }
  3049. return 0;
  3050. }
  3055. // pInfo所指向的数据包中，annexdata.siAnnData[]变量的含意解释：
  3056. // [0] — 位深度，可以是1、4、8、16(555)、24、32(888)这六个值
  3057. // 中的一个，不能是其他值。另：不能存储为RLE格式
  3058. // [1] — 是否使用原始调色板。0 — 表示使用，1 — 表示使用当前
  3059. // 计算机缺省调色板
  3060. int _Save(CFile& pf, LPINFOSTR pInfo)
  3061. {
  3062. PBYTE lpBits;
  3063. HBITMAP hBmp;
  3065. ASSERT(pInfo);
  3066. int dibitcount = pInfo->annexdata.siAnnData[0]; // 目标文件的位深度
  3067. int palnum = _get_palette_size(dibitcount); // 调色板项数目
  3069. BITMAPINFO *pbmi = (BITMAPINFO*)::GlobalAlloc(GPTR, sizeof(BITMAPINFOHEADER)+sizeof(RGBQUAD)*palnum);
  3070. RGBQUAD *ppal = (RGBQUAD*)((PBYTE)pbmi+sizeof(BITMAPINFOHEADER));
  3072. if (!pbmi)
  3073. {
  3074. pInfo->result = ER_MEMORYERR;
  3075. return 2; // 内存不足
  3076. }
  3078. HWND hWnd = ::GetDesktopWindow();
  3079. HDC hDC = ::GetDC(hWnd);
  3081. pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  3082. pbmi->bmiHeader.biPlanes = 1;
  3083. pbmi->bmiHeader.biBitCount = dibitcount;
  3084. pbmi->bmiHeader.biCompression = BI_RGB;
  3085. pbmi->bmiHeader.biSizeImage = 0;
  3086. pbmi->bmiHeader.biWidth = pInfo->sDIBInfo.bmi.biWidth;
  3087. pbmi->bmiHeader.biHeight = pInfo->sDIBInfo.bmi.biHeight;
  3088. pbmi->bmiHeader.biClrImportant = 0;
  3089. pbmi->bmiHeader.biClrUsed = 0;
  3090. pbmi->bmiHeader.biXPelsPerMeter = (int)(::GetDeviceCaps(hDC,LOGPIXELSX)*(float)39.373);
  3091. pbmi->bmiHeader.biYPelsPerMeter = (int)(::GetDeviceCaps(hDC,LOGPIXELSY)*(float)39.373);
  3093. if (palnum)
  3094. {
  3095. switch(pInfo->annexdata.siAnnData[1])
  3096. {
  3097. case 0: // 使用原位图调色板（读取的原始图像文件必需也是BMP位图）
  3098. if (pInfo->imginfo.imgformat == IMF_BMP)
  3099. {
  3100. if (pInfo->imginfo.bitcount == (unsigned int)dibitcount) // 只有原始图像的格式与目标文件的位深度相同时，才有意义
  3101. {
  3102. ASSERT(pInfo->pImgInfo); // 原始数据必需有效
  3103. ASSERT(((BITMAPINFOHEADER*)(pInfo->pImgInfo))->biSize == sizeof(BITMAPINFOHEADER));
  3105. RGBQUAD *porg = (RGBQUAD*)(((BITMAPINFOHEADER*)(pInfo->pImgInfo))+1);
  3106. int palnum2 = ((BITMAPINFOHEADER*)(pInfo->pImgInfo))->biClrUsed;
  3107. palnum2 = (palnum2) ? palnum2:palnum;
  3108. ASSERT(palnum2 <= palnum);
  3110. for (int i=0;i<palnum2;i++)
  3111. {
  3112. ppal[i].rgbBlue = porg[i].rgbBlue;
  3113. ppal[i].rgbGreen = porg[i].rgbGreen;
  3114. ppal[i].rgbRed = porg[i].rgbRed;
  3115. ppal[i].rgbReserved = 0;
  3116. }
  3117. break;
  3118. }
  3119. }
  3120. else
  3121. {
  3122. ; // 仍使用系统缺省调色板
  3123. }
  3124. case 1: // 使用系统缺省调色板
  3125. {
  3126. LPPALETTEENTRY pal = (LPPALETTEENTRY)::GlobalAlloc(GPTR, sizeof(PALETTEENTRY)*palnum);
  3127. if (!pal)
  3128. {
  3129. ::GlobalFree(pbmi);
  3130. ::ReleaseDC(hWnd, hDC);
  3131. pInfo->result = ER_MEMORYERR;
  3132. return 2; // 内存不足
  3133. }
  3134. ::GetSystemPaletteEntries(hDC, 0, palnum, pal);
  3135. for (int i=0;i<palnum;i++)
  3136. {
  3137. ppal[i].rgbBlue = pal[i].peBlue;
  3138. ppal[i].rgbGreen = pal[i].peGreen;
  3139. ppal[i].rgbRed = pal[i].peRed;
  3140. ppal[i].rgbReserved = 0;
  3141. }
  3142. ::GlobalFree(pal);
  3143. }
  3144. break;
  3145. default:
  3146. ASSERT(FALSE);
  3147. break;
  3148. }
  3149. }
  3151. hBmp = CreateDIBSection(hDC, pbmi, DIB_RGB_COLORS, (void**)&lpBits, NULL, 0);
  3152. if (hBmp == NULL)
  3153. {
  3154. ::GlobalFree(pbmi);
  3155. ::ReleaseDC(hWnd, hDC);
  3156. pInfo->result = ER_SYSERR;
  3157. return 5; // 操作系统不稳定
  3158. }
  3160. if (!SetDIBits(hDC, hBmp, 0, pInfo->imginfo.height, pInfo->_pbdata, (const BITMAPINFO*)&pInfo->sDIBInfo, DIB_RGB_COLORS))
  3161. {
  3162. ::GlobalFree(pbmi);
  3163. ::ReleaseDC(hWnd, hDC);
  3164. ::DeleteObject(hBmp);
  3165. pInfo->result = ER_SYSERR;
  3166. return 5;
  3167. }
  3169. ::ReleaseDC(hWnd, hDC);
  3171. BITMAPFILEHEADER bmf;
  3172.  
  3173. bmf.bfType = DIB_HEADER_MARKER;
  3174. bmf.bfSize = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+
  3175. sizeof(RGBQUAD)*palnum+((pInfo->imginfo.width*dibitcount+31)/32)*4*pInfo->imginfo.height;
  3176. bmf.bfReserved1 = 0;
  3177. bmf.bfReserved2 = 0;
  3178. bmf.bfOffBits = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+
  3179. sizeof(RGBQUAD)*palnum;
  3182. TRY
  3183. {
  3184. // writing bitmap file header
  3185. pf.SeekToBegin();
  3186. pf.Write((const void *)&bmf, sizeof(BITMAPFILEHEADER));
  3188. // writing bitmap info header
  3189. pf.Write((const void *)pbmi, sizeof(BITMAPINFOHEADER));
  3190. }
  3191. CATCH(CFileException, e)
  3192. {
  3193. ::GlobalFree(pbmi);
  3194. ::DeleteObject(hBmp);
  3195. pInfo->result = ER_FILERWERR;
  3196. return 1; // 写文件时出错
  3197. }
  3198. END_CATCH
  3200. ::GlobalFree(pbmi);
  3201. RGBQUAD *palette = NULL;
  3203. TRY
  3204. {
  3205. if (palnum)
  3206. {
  3207. palette = (RGBQUAD*)::GlobalAlloc(GPTR, sizeof(RGBQUAD)*palnum);
  3208. if (!palette)
  3209. {
  3210. ::DeleteObject(hBmp);
  3211. pInfo->result = ER_MEMORYERR;
  3212. return 2; // 内存不足
  3213. }
  3215. HDC hCompDC = ::CreateCompatibleDC(NULL);
  3216. HBITMAP hOldBmp = (HBITMAP)::SelectObject(hCompDC, hBmp);
  3218. ::GetDIBColorTable(hCompDC, 0, palnum, palette);
  3220. ::SelectObject(hCompDC, hOldBmp);
  3221. ::DeleteDC(hCompDC);
  3223. // writing color table.
  3224. pf.Write((const void *)palette, sizeof(RGBQUAD)*palnum);
  3226. ::GlobalFree(palette);
  3227. }
  3229. pf.WriteHuge((const void *)lpBits, ((pInfo->imginfo.width*dibitcount+31)/32)*4*pInfo->imginfo.height);
  3230. }
  3231. CATCH(CFileException, e)
  3232. {
  3233. if (palette) ::GlobalFree(palette);
  3234. ::DeleteObject(hBmp);
  3235. pInfo->result = ER_FILERWERR;
  3236. return 1; // 写文件时出错
  3237. }
  3238. END_CATCH
  3240. ::DeleteObject(hBmp);
  3242. pInfo->result = ER_SUCCESS;
  3244. return 0; // 写文件成功
  3245. }
  3248. // 判断标准图像的位格式
  3249. DESFORMAT _get_desformat(LPINFOSTR pInfo)
  3250. {
  3251. ASSERT(pInfo);
  3252. // ASSERT(pInfo->state >= PKST_PASSVER);
  3253. ASSERT(pInfo->sDIBInfo.bmi.biPlanes == 1);
  3255. DESFORMAT result;
  3257. switch(pInfo->sDIBInfo.bmi.biBitCount)
  3258. {
  3259. case 32:
  3260. /******************************************************
  3261. 32位掩码示意图
  3262.     高               ->                 低
  3263. 0000 0000   0000 0000   0000 0000   0000 0000  888格式
  3264.             1111 1111  ------------------------R
  3265.                         1111 1111 -------------G
  3266.                                     1111 1111--B
  3267. * Win95 系统只支持这一种格式
  3268. ******************************************************/
  3269. if (pInfo->sDIBInfo.bmi.biCompression == BI_RGB)
  3270. {
  3271. result = DF_32;
  3272. break;
  3273. }
  3275. if ((pInfo->sDIBInfo.rmask == 0xff0000)&&
  3276. (pInfo->sDIBInfo.gmask == 0xff00)&&
  3277. (pInfo->sDIBInfo.bmask == 0xff))
  3278. result = DF_32;
  3279. else
  3280. {
  3281. ASSERT(FALSE); // 只支持888格式
  3282. result = DF_NULL;
  3283. }
  3284. break;
  3285. case 24:
  3286. result = DF_24;
  3287. break;
  3288. case 16:
  3289. /*******************************************
  3290. 16位掩码示意图
  3292.   高字节      低字节
  3293. 0000 0000   0000 0000 
  3294.    1 1111--B // 555格式
  3295.    11 111 -------G
  3296.  111 11  --------------R
  3297. 0
  3298.    1 1111--B // 565格式
  3299.   111   111 -------G
  3300. 1111 1   --------------R
  3302. * Win95 系统只支持以上两种格式
  3303. *******************************************/
  3304. if (pInfo->sDIBInfo.bmi.biCompression == BI_RGB)
  3305. {
  3306. result = DF_16_555;
  3307. break;
  3308. }
  3310. if ((pInfo->sDIBInfo.rmask == 0x7c00)&&
  3311. (pInfo->sDIBInfo.gmask == 0x3e0)&&
  3312. (pInfo->sDIBInfo.bmask == 0x1f))
  3313. result = DF_16_555;
  3314. else if ((pInfo->sDIBInfo.rmask == 0xf800)&&
  3315. (pInfo->sDIBInfo.gmask == 0x7e0)&&
  3316. (pInfo->sDIBInfo.bmask == 0x1f))
  3317. result = DF_16_565;
  3318. else
  3319. result = DF_NULL;
  3320. break;
  3321. default:
  3322. ASSERT(FALSE); // 不接受其它格式
  3323. result = DF_NULL;
  3324. break;
  3325. }
  3327. return result;
  3328. }
  3333. // 判断标准图像的位格式
  3334. SOUFORMAT _get_souformat(LPBITMAPINFO pInfo)
  3335. {
  3336. ASSERT(pInfo->bmiHeader.biSize);
  3338. SOUFORMAT result;
  3340. switch(pInfo->bmiHeader.biBitCount)
  3341. {
  3342. case 1:
  3343. ASSERT(pInfo->bmiHeader.biCompression == BI_RGB);
  3344. result = SF_1;
  3345. break;
  3346. case 4:
  3347. if (pInfo->bmiHeader.biCompression == BI_RGB)
  3348. result = SF_4;
  3349. else if ((pInfo->bmiHeader.biCompression == BI_RLE4)&&
  3350.  (pInfo->bmiHeader.biHeight > 0)) // 正向的位图不能被压缩
  3351. result = SF_4_RLE;
  3352. else
  3353. result = SF_NULL;
  3354. break;
  3355. case 8:
  3356. if (pInfo->bmiHeader.biCompression == BI_RGB)
  3357. result = SF_8;
  3358. else if ((pInfo->bmiHeader.biCompression == BI_RLE8)&&
  3359.  (pInfo->bmiHeader.biHeight > 0))
  3360. result = SF_8_RLE;
  3361. else
  3362. result = SF_NULL;
  3363. break;
  3364. case 16:
  3365. {
  3366. /*******************************************
  3367. 16位掩码示意图
  3369.   高字节      低字节
  3370. 0000 0000   0000 0000 
  3371.    1 1111--B // 555格式
  3372.    11 111 -------G
  3373.  111 11  --------------R
  3374. 0
  3375.    1 1111--B // 565格式
  3376.   111   111 -------G
  3377. 1111 1   --------------R
  3379. * Win95 系统只支持以上两种格式
  3380. *******************************************/
  3381. if (pInfo->bmiHeader.biCompression == BI_RGB)
  3382. {
  3383. result = SF_16_555;
  3384. break;
  3385. }
  3387. DWORD *pMark = (DWORD*)((LPBITMAPINFOHEADER)pInfo+1);
  3389. if ((pMark[0] == 0x7c00)&&(pMark[1] == 0x3e0)&&(pMark[2] == 0x1f))
  3390. result = SF_16_555;
  3391. else if ((pMark[0] == 0xf800)&&(pMark[1] == 0x7e0)&&(pMark[2] == 0x1f))
  3392. result = SF_16_565;
  3393. else
  3394. result = SF_NULL;
  3395. break;
  3396. }
  3397. case 24:
  3398. ASSERT(pInfo->bmiHeader.biCompression == BI_RGB);
  3399. result = SF_24;
  3400. break;
  3401. case 32:
  3402. {
  3403. /******************************************************
  3404. 32位掩码示意图
  3405.     高               ->                 低
  3406. 0000 0000   0000 0000   0000 0000   0000 0000  888格式
  3407.             1111 1111  ------------------------R
  3408.                         1111 1111 -------------G
  3409.                                     1111 1111--B
  3410. * Win95 系统只支持这一种格式
  3411. ******************************************************/
  3412. if (pInfo->bmiHeader.biCompression == BI_RGB)
  3413. {
  3414. result = SF_32;
  3415. break;
  3416. }
  3418. DWORD *pMark = (DWORD*)((LPBITMAPINFOHEADER)pInfo+1);
  3420. if ((pMark[0] == 0xff0000)&&(pMark[1] == 0x00ff00)&&(pMark[2] == 0xff))
  3421. result = SF_32;
  3422. else
  3423. result = SF_NULL; // 只支持888格式
  3424. break;
  3425. }
  3426. default:
  3427. result = SF_NULL;
  3428. break;
  3429. }
  3431. return result;
  3432. }
  3434. // 将指定的RGB颜色分量转换成555格式（WORD型值返回）
  3435. WORD _cnv_rgb_to_555(BYTE red, BYTE green, BYTE blue)
  3436. {
  3437. WORD result = 0;
  3439. result = (((WORD)red>>3)<<10)|(((WORD)green>>3)<<5)|((WORD)blue>>3);
  3441. return result;
  3442. }
  3445. // 将指定的555格式的颜色转换成RGB颜色分量
  3446. void _cnv_555_to_rgb(WORD col, PBYTE red, PBYTE green, PBYTE blue)
  3447. {
  3448. // 在555转换到RGB时，将像素的亮度调到最大
  3449. *red = (BYTE)((col>>7)&0xf8);
  3450. *green = (BYTE)((col>>2)&0xf8);
  3451. *blue = (BYTE)(col<<3);
  3452. }
  3455. // 将指定的RGB颜色分量转换成565格式（WORD型值返回）
  3456. WORD _cnv_rgb_to_565(BYTE red, BYTE green, BYTE blue)
  3457. {
  3458. WORD result = 0;
  3460. result = (((WORD)red>>3)<<11)|(((WORD)green>>2)<<5)|((WORD)blue>>3);
  3462. return result;
  3463. }
  3466. // 将指定的565格式的颜色转换成RGB颜色分量
  3467. void _cnv_565_to_rgb(WORD col, PBYTE red, PBYTE green, PBYTE blue)
  3468. {
  3469. // 在565转换到RGB时，将像素的亮度调到最大
  3470. *red = (BYTE)((col>>8)&0xf8);
  3471. *green = (BYTE)((col>>3)&0xfc);
  3472. *blue = (BYTE)(col<<3);
  3473. }
  3476. // 将指定的RGB颜色分量转换成888格式（DWORD型值返回）
  3477. DWORD _cnv_rgb_to_888(BYTE red, BYTE green, BYTE blue)
  3478. {
  3479. DWORD result = 0;
  3481. result = ((DWORD)red<<16)|((DWORD)green<<8)|(DWORD)blue;
  3483. return result;
  3484. }
  3488. // 向4位缓冲区写像素（只供_from_4_RLE_read()函数内部调用）
  3489. // 形参mark含意：0-初始化变量  1-写像素  2-移动到指定点  3-结束操作  4-获取当前地址
  3490. // 注：当mark等于2时，参数num将作为像素除2余数被代入，来对iCurOff赋值
  3491. PBYTE _write2buff4RLE(int mark, int num, BYTE pix, PBYTE lpDesData)
  3492. {
  3493. static PBYTE lpDes; // 缓冲区基地址
  3494. static PBYTE lpCur; // 缓冲区当前写地址
  3495. static int   iCurOff; // 在字节中的当前位置，0-高半字节  1-低半字节
  3496. int i;
  3497. BYTE pixa[2];
  3499. switch(mark)
  3500. {
  3501. case 0: // 初始化变量
  3502. lpDes = lpDesData;
  3503. lpCur = lpDes;
  3504. iCurOff = 0;
  3505. break;
  3506. case 1: // 写像素
  3507. pixa[0] = pix>>4;
  3508. pixa[1] = pix&0xf;
  3509. for (i=0;i<num;i++)
  3510. {
  3511. if (iCurOff == 0) // 左像素
  3512. {
  3513. *lpCur = pixa[i%2]<<4;
  3514. iCurOff = 1;
  3515. }
  3516. else // 右像素
  3517. {
  3518. ASSERT(iCurOff == 1);
  3519. *lpCur |= pixa[i%2];
  3520. lpCur++;
  3521. iCurOff = 0;
  3522. }
  3523. }
  3524. break;
  3525. case 2: // 移动到指定点
  3526. lpCur = lpDesData;
  3527. iCurOff = num;
  3528. break;
  3529. case 3: // 结束操作
  3530. lpDes = NULL;
  3531. lpCur = lpDes;
  3532. iCurOff = 0;
  3533. break;
  3534. case 4: // 获取当前地址
  3535. break;
  3536. default:
  3537. ASSERT(FALSE);
  3538. break;
  3539. }
  3541. return lpCur;
  3542. }
  3546. // 向8位缓冲区写像素（只供_from_8_RLE_read()函数内部调用）
  3547. // 形参mark含意：0-初始化变量  1-写像素  2-移动到指定点  3-结束操作  4-获取当前地址
  3548. PBYTE _write2buff8RLE(int mark, int num, BYTE pix, PBYTE lpDesData)
  3549. {
  3550. static PBYTE lpDes; // 缓冲区基地址
  3551. static PBYTE lpCur; // 缓冲区当前写地址
  3552. int i;
  3554. switch(mark)
  3555. {
  3556. case 0: // 初始化变量
  3557. lpDes = lpDesData;
  3558. lpCur = lpDes;
  3559. break;
  3560. case 1: // 写像素
  3561. for (i=0;i<num;i++)
  3562. *lpCur++ = pix;
  3563. break;
  3564. case 2: // 移动到指定点
  3565. lpCur = lpDesData;
  3566. break;
  3567. case 3: // 结束操作
  3568. lpDes = NULL;
  3569. lpCur = lpDes;
  3570. break;
  3571. case 4: // 获取当前地址
  3572. break;
  3573. default:
  3574. ASSERT(FALSE);
  3575. break;
  3576. }
  3577. return lpCur;
  3578. }
  3581. // 计算调色板的尺寸
  3582. int _get_palette_size(int bitcount)
  3583. {
  3584. int result;
  3586. switch(bitcount)
  3587. {
  3588. case 1:
  3589. result = 2;
  3590. break;
  3591. case 4:
  3592. result = 16;
  3593. break;
  3594. case 8:
  3595. result = 256;
  3596. break;
  3597. case 16:
  3598. case 24:
  3599. case 32:
  3600. result = 0;
  3601. break;
  3602. default:
  3603. ASSERT(FALSE); // 非法情况
  3604. result = 0;
  3605. break;
  3606. }
  3607. return result;
  3608. }