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

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

图形图象

开发平台：

Visual C++

TgaModule.cpp：源码内容
  1. // TgaModule.cpp : Defines the initialization routines for the DLL.
  2. //
  4. #include "stdafx.h"
  5. #include "TgaModule.h"
  7. #ifdef _DEBUG
  8. #define new DEBUG_NEW
  9. #undef THIS_FILE
  10. static char THIS_FILE[] = __FILE__;
  11. #endif
  13. #define _CHECKOVER
  14. //#define DIBSCANLINE_WIDTHBYTES(bits)    ((((bits)+31)>>5)<<2)
  15. #define DIBSCANLINE_WIDTHBYTES(bits)    (((bits)+7)>>3)
  16. #define MODULE_BUILDID 1
  17. #define RWPROGRESSSIZE 100
  18. #define BGR(b,g,r)          ((COLORREF)(((BYTE)(b)|((WORD)((BYTE)(g))<<8))|(((DWORD)(BYTE)(r))<<16)))
  19. #define _OVERCHECK
  21. static char ModuleProcessImgType[]="TGA"; // 本模块能处理的图像类型
  22. static char WriterList[]="晓月儿"; // 本模块的作者列表
  23. static char WriterMess[]="我爱你,我一直在努力!"; // 作者留言
  24. BOOL IsFileExist(char *lpFileName);
  25. //
  26. // Note!
  27. //
  28. // If this DLL is dynamically linked against the MFC
  29. // DLLs, any functions exported from this DLL which
  30. // call into MFC must have the AFX_MANAGE_STATE macro
  31. // added at the very beginning of the function.
  32. //
  33. // For example:
  34. //
  35. // extern "C" BOOL PASCAL EXPORT ExportedFunction()
  36. // {
  37. // AFX_MANAGE_STATE(AfxGetStaticModuleState());
  38. // // normal function body here
  39. // }
  40. //
  41. // It is very important that this macro appear in each
  42. // function, prior to any calls into MFC.  This means that
  43. // it must appear as the first statement within the 
  44. // function, even before any object variable declarations
  45. // as their constructors may generate calls into the MFC
  46. // DLL.
  47. //
  48. // Please see MFC Technical Notes 33 and 58 for additional
  49. // details.
  50. //
  52. // 在图像读写模块中，如果想分配内存，请使用API函数GlobalAlloc()
  53. // ，如果想释放内存请使用GlobalFree()函数。不要使用诸如：new
  54. // 、malloc()等函数。这是为了使各模块之间可以异地释放内存。
  55. //
  56. //
  58. /////////////////////////////////////////////////////////////////////////////
  59. // CTgaModuleApp
  61. BEGIN_MESSAGE_MAP(CTgaModuleApp, CWinApp)
  62. //{{AFX_MSG_MAP(CTgaModuleApp)
  63. // NOTE - the ClassWizard will add and remove mapping macros here.
  64. //    DO NOT EDIT what you see in these blocks of generated code!
  65. //}}AFX_MSG_MAP
  66. END_MESSAGE_MAP()
  68. /////////////////////////////////////////////////////////////////////////////
  69. // CTgaModuleApp construction
  71. CTgaModuleApp::CTgaModuleApp()
  72. {
  73. // TODO: add construction code here,
  74. // Place all significant initialization in InitInstance
  75. }
  77. /////////////////////////////////////////////////////////////////////////////
  78. // The one and only CTgaModuleApp object
  80. CTgaModuleApp theApp;
  82. // 接口函数声明 — 第一层，唯一与外界联系的接口
  83. int WINAPI AccessTGAModule(INFOSTR *pInfo)
  84. {
  85. // 这个函数可以不作修改的使用，除非你的返回值多于两种。
  87. switch(pInfo->comm)
  88. {
  89. case CMD_GETPROCTYPE: // 获取本模块能处理的图像类型
  90. _fnCMD_GETPROCTYPE(pInfo);
  91. break;
  92. case CMD_GETWRITERS: // 获取本模块的作者列表，多人时用逗号分隔
  93. _fnCMD_GETWRITERS(pInfo);
  94. break;
  95. case CMD_GETWRITERMESS: // 获取作者们的留言
  96. _fnCMD_GETWRITERMESS(pInfo);
  97. break;
  98. case CMD_GETBUILDID: // 获取图像模块内部版本号
  99. _fnCMD_GETBUILDID(pInfo);
  100. break;
  101. case CMD_IS_VALID_FILE: // 判断指定文件是否是有效的WMF文件
  102. _fnCMD_IS_VALID_FILE(pInfo);
  103. break;
  104. case CMD_GET_FILE_INFO: // 获取指定文件的信息
  105. _fnCMD_GET_FILE_INFO(pInfo);
  106. break;
  107. case CMD_LOAD_FROM_FILE: // 从指定图像文件中读取数据
  108. _fnCMD_LOAD_FROM_FILE(pInfo);
  109. break;
  110. case CMD_SAVE_TO_FILE: // 将数据保存到指定文件中
  111. _fnCMD_SAVE_TO_FILE(pInfo);
  112. break;
  113. case CMD_IS_SUPPORT: // 查询某个命令是否被支持
  114. _fnCMD_IS_SUPPORT(pInfo);
  115. break;
  116. case CMD_RESIZE: // 从新获取指定尺寸的图像位数据（只适用于矢量图像）
  117. _fnCMD_RESIZE(pInfo);
  118. break;
  119. default:
  120. pInfo->result = ER_ILLCOMM; // 非法命令
  121. ASSERT(FALSE); // 调用者的程序设计有问题 :-)
  122. break;
  123. }
  125. // 执行命令成功返回1, 失败返回0
  126. return (pInfo->result==ER_SUCCESS)? 1:0;
  127. }
  133. // 命令解释函数 — 第二层解释函数
  134. //********************************************************************//
  136. // 操作命令解释函数---解释：CMD_IS_SUPPORT命令
  137. // 查询某个命令是否被支持
  138. void _fnCMD_IS_SUPPORT(INFOSTR *pInfo)
  139. {
  140. // 这个函数是为客户程序查询时使用，如果你实现了对某个命令的
  141. // 解释，可修改相应的case中的设置，使其返回ER_SUCCESS，这就
  142. // 表示你的模块已经支持该命令了。同时，现在的这个文件中已包
  143. // 含了对前四个命令的解释，你只需向还未支持的命令函数中添加
  144. // 代码即可。
  146. ASSERT(pInfo->result == ER_EMPTY);
  148. switch(pInfo->annexdata.cmAnnData)  
  149. {
  150. case CMD_GETPROCTYPE: // 获取本模块能处理的图像类型
  151. pInfo->result = ER_SUCCESS;
  152. break;
  153. case CMD_GETWRITERS: // 获取本模块的作者列表，多人时用逗号分隔
  154. pInfo->result = ER_SUCCESS;
  155. break;
  156. case CMD_GETWRITERMESS: // 获取作者们的留言
  157. pInfo->result = ER_SUCCESS;
  158. break;
  159. case CMD_GETBUILDID: // 获取图像模块内部版本号
  160. pInfo->result = ER_SUCCESS;
  161. break;
  162. case CMD_IS_VALID_FILE: // 判断指定文件是否是有效的WMF文件
  163. pInfo->result = ER_SUCCESS;
  164. break;
  165. case CMD_GET_FILE_INFO: // 获取指定文件的信息
  166. pInfo->result = ER_SUCCESS;
  167. break;
  168. case CMD_LOAD_FROM_FILE: // 从指定图像文件中读取数据
  169. pInfo->result = ER_SUCCESS;
  170. break;
  171. case CMD_SAVE_TO_FILE: // 将数据保存到指定文件中
  172. pInfo->result = ER_NOTSUPPORT;
  173. break;
  174. case CMD_IS_SUPPORT: // 查询某个命令是否被支持
  175. pInfo->result = ER_SUCCESS;
  176. break;
  177. case CMD_RESIZE: // 获取指定尺寸的图像（只适用于矢量图像）
  178. pInfo->result = ER_NOTSUPPORT;
  179. break;
  180. default:
  181. pInfo->result = ER_NOTSUPPORT;
  182. break;
  183. }
  184. }
  187. // 操作命令解释函数---解释：CMD_GETPROCTYPE命令
  188. // 获取本模块能处理的图像类型，如：BMP，PCX等等
  189. void _fnCMD_GETPROCTYPE(INFOSTR *pInfo)
  190. {
  191. // 这是预定义的函数代码，你可以不必修改的使用。
  193. // 根据接口定义，此时附加数据应被清空为0，所以下此断言
  194. ASSERT(pInfo->annexdata.scAnnData[0] == 0);
  195. ASSERT(pInfo->result == ER_EMPTY);
  196. // 复制能处理的类型字符串
  197. ::CopyMemory((PVOID)pInfo->annexdata.scAnnData, (PVOID)ModuleProcessImgType, 
  198. sizeof(ModuleProcessImgType));
  200. pInfo->result = ER_SUCCESS;
  201. }
  205. // 操作命令解释函数---解释：CMD_GETWRITER命令
  206. // 获取本模块的作者列表，多人时用逗号分隔
  207. void _fnCMD_GETWRITERS(INFOSTR *pInfo)
  208. {
  209. // 这是预定义的函数代码，你可以不必修改的使用。
  211. // 根据接口定义，此时附加数据应被清空为0，所以下此断言
  212. ASSERT(pInfo->annexdata.scAnnData[0] == 0);
  213. ASSERT(pInfo->result == ER_EMPTY);
  214. // 复制开发者名单串
  215. ::CopyMemory((PVOID)pInfo->annexdata.scAnnData, (PVOID)WriterList, 
  216. sizeof(WriterList));
  218. pInfo->result = ER_SUCCESS;
  219. }
  222. // 操作命令解释函数---解释：CMD_GETWRITERMESS命令
  223. // 获取作者们的留言
  224. void _fnCMD_GETWRITERMESS(INFOSTR *pInfo)
  225. {
  226. // 这是预定义的函数代码，你可以不必修改的使用。
  228. // 根据接口定义，此时附加数据应被清空为0，所以下此断言
  229. ASSERT(pInfo->annexdata.scAnnData[0] == 0);
  230. ASSERT(pInfo->result == ER_EMPTY);
  231. // 复制开发者们的留言字符串
  232. ::CopyMemory((PVOID)pInfo->annexdata.scAnnData, (PVOID)WriterMess, 
  233. sizeof(WriterMess));
  235. pInfo->result = ER_SUCCESS;
  236. }
  240. // 操作命令解释函数---解释：CMD_GETBUILDID命令
  241. // 获取图像模块内部版本号
  242. void _fnCMD_GETBUILDID(INFOSTR *pInfo)
  243. {
  244. // 这是预定义的函数代码，你可以不必修改的使用。
  246. // 根据接口定义，此时annexdata.dwAnnData应被设为0，所以下此断言
  247. ASSERT(pInfo->annexdata.dwAnnData == 0);
  248. ASSERT(pInfo->result == ER_EMPTY);
  249. // 填写内部版本号码
  250. pInfo->annexdata.dwAnnData = MODULE_BUILDID;
  252. pInfo->result = ER_SUCCESS;
  253. }
  259. // 操作命令解释函数---解释：CMD_SAVE_TO_FILE命令
  260. // 将数据保存到指定文件中
  261. void _fnCMD_SAVE_TO_FILE(INFOSTR *pInfo)
  262. {
  263. // 这个命令不一定要解释，你可以参考本图像格式的具体境况来决定
  264. // 是否解释该命令。
  265. // 如果你想解释该命令，请在下面加入代码，并修改pInfo->result的返回值：
  266. // ----------------------------------------------------------------->
  268. pInfo->result = ER_NOTSUPPORT;
  269. }
  274. // 操作命令解释函数---解释：CMD_RESIZE命令
  275. // 重新获取指定尺寸的图像位数据（只适用于矢量图像）
  276. void _fnCMD_RESIZE(INFOSTR *pInfo)
  277. {
  278. // 这个命令一般的图像读写模块不需要支持，它只适用于矢量图像，
  279. // 比如WMF、EMF之类。
  280. // 如果你想解释该命令，请在下面加入代码，并修改pInfo->result的返回值：
  281. // ----------------------------------------------------------------->
  283. pInfo->result = ER_NOTSUPPORT;
  284. }
  286. // 操作命令解释函数---解释：CMD_IS_VALID_FILE命令
  287. // 判断指定文件是否是有效的TGA文件
  288. void _fnCMD_IS_VALID_FILE(INFOSTR *pInfo)
  289. {
  290. TGAHEADER tgaHeader;
  291. DWORD dwSize;
  292. UINT uRet, uRet2;
  293. CFile file;
  295. // 检验入口参数是否符合接口定义
  296. ASSERT(pInfo->result == ER_EMPTY);
  297. ASSERT(pInfo->annexdata.iAnnData == 0);
  298. ASSERT(::strlen(pInfo->filename));
  299. ASSERT(pInfo->state == PKST_NOTVER);
  301. ASSERT(pInfo);
  303. pInfo->result=ER_SUCCESS;
  306. // 先判断指定的文件是否存在
  307. if (!IsFileExist(pInfo->filename))
  308. pInfo->result = ER_COMMINFOERR;
  309. else
  310. {
  311. // 打开指定文件
  312. if (!file.Open(pInfo->filename, CFile::modeRead))
  313. {
  314. pInfo->result = ER_FILERWERR; // 打开文件时出错
  315. return;
  316. }
  318. // 获取TGA文件的长度（以字节为单位）
  319. dwSize = file.GetLength();
  321. // 用长度判断
  322. if (dwSize < sizeof(TGAHEADER))
  323. {
  324. // 这不是一个TGA文件，TGA文件的长度起码大于文件头
  325. // 加信息头结构的长度
  326. pInfo->result=ER_BADIMAGE;
  327. file.Close();
  328. return;
  329. }
  331. // 读取TGA的文件头结构，并检查它的有效性
  332. file.SeekToBegin();
  333. uRet  = file.Read(&tgaHeader, sizeof(TGAHEADER));
  334. uRet2=file.Seek(tgaHeader.bID_Length,CFile::current);
  336. if ((uRet != sizeof(TGAHEADER))||(uRet2!=sizeof(TGAHEADER)+tgaHeader.bID_Length))
  337. {
  338. pInfo->result = ER_BADIMAGE; // 读文件时出错
  339. file.Close();
  340. return;
  341. }
  344. // 判断文件头的图象类型标志
  345. switch(tgaHeader.bImageType)
  346. {
  347. case TGA_NULL:
  348. case TGA_RLEPAL:
  349. case TGA_RLECOLOR:
  350. case TGA_RLEGRAY:
  351. break;
  352. case TGA_UNCPSPAL:
  353. case TGA_UNCPSCOLOR:
  354. case TGA_UNCPSGRAY:
  355. if(file.GetLength()<sizeof(TGAHEADER)+tgaHeader.bID_Length+((tgaHeader.bBits+7)>>3)*tgaHeader.wDepth*tgaHeader.wWidth+tgaHeader.wPalLength*((tgaHeader.bPalBits+7)>>3))
  356. {
  357. TRACE("File length:%d",file.GetLength());
  358. TRACE("nDesired Length:%d",sizeof(TGAHEADER)+tgaHeader.bID_Length+((tgaHeader.bBits+7)>>3)*tgaHeader.wDepth*tgaHeader.wWidth+tgaHeader.wPalLength*((tgaHeader.bPalBits+7)>>3));
  359. file.Close();
  360. pInfo->result=ER_BADIMAGE;
  361. return;
  362. }
  364. break;
  365. default: //未知文件类型
  366. file.Close();
  367. pInfo->result=ER_BADIMAGE;
  368. return;
  369. }
  371. //因为TGA可能采用压缩算法
  372. //或者有附加信息
  373. //所以判断文件总长和应有长度基本上无意义
  374. // 到此，大致可以表明该文件是一个有效的TGA文件，iAnnData变量设为1
  375. pInfo->annexdata.iAnnData = 1;
  376. pInfo->state = PKST_PASSVER; // 表示通过校验
  377. file.Close();
  378. }//End else
  379. }
  382. // 操作命令解释函数---解释：CMD_GET_FILE_INFO命令
  383. // 获取指定文件的信息
  384. void _fnCMD_GET_FILE_INFO(INFOSTR *pInfo)
  385. {
  386. CFile file;
  387. CFileStatus status;
  388. UINT uRet;
  389. TGAHEADER tgaHeader;
  391. // 检验入口参数是否符合接口定义
  392. ASSERT(pInfo->result == ER_EMPTY);
  393. ASSERT(::strlen(pInfo->filename));
  394. // 此时，该文件必需是一个已存在的、并且是有效的BMP文件
  395. ASSERT(pInfo->state == PKST_PASSVER);
  396. // 客户模块必需要先将imginfo清空为0
  397. ASSERT(pInfo->imginfo.imgtype == IMT_NULL);
  399. // 打开指定文件
  400. if (!file.Open(pInfo->filename, CFile::modeRead))
  401. {
  402. pInfo->result = ER_FILERWERR;
  403. return;
  404. }
  406. // 读取TGA的文件头结构
  407. file.SeekToBegin();
  408. uRet  = file.Read((LPSTR)&tgaHeader, sizeof(TGAHEADER));
  410. if (uRet != sizeof(TGAHEADER))
  411. {
  412. file.Close();
  413. pInfo->result = ER_FILERWERR;
  414. return;
  415. }
  420. LPIMAGEINFOSTR lpImgInfoStr = &pInfo->imginfo;
  422. // 获取文件的长度、图像的宽度、高度等信息
  423. lpImgInfoStr->imgtype = IMT_RESSTATIC;
  424. lpImgInfoStr->imgformat = IMF_TGA;
  425. lpImgInfoStr->filesize = file.GetLength();
  426. lpImgInfoStr->width = tgaHeader.wWidth;
  427. // 图像的高度值有时可能是负值，所以使用了abs()函数
  428. lpImgInfoStr->height = (DWORD)::abs(tgaHeader.wDepth);
  429. lpImgInfoStr->bitcount = (DWORD)tgaHeader.bBits;
  431. switch(tgaHeader.bImageType)
  432. {
  433. case TGA_NULL:
  434. file.Close();
  435. pInfo->result=ER_BADIMAGE;
  436. return;
  437. case TGA_UNCPSPAL:
  438. case TGA_UNCPSCOLOR:
  439. case TGA_UNCPSGRAY:
  440. lpImgInfoStr->compression=ICS_RGB;
  441. break;
  442. case TGA_RLEPAL:
  443. case TGA_RLECOLOR:
  444. case TGA_RLEGRAY:
  445. switch(tgaHeader.bBits)
  446. {
  447. case 8:
  448. lpImgInfoStr->compression=ICS_RLE8;
  449. break;
  450. case 15:
  451. case 16:
  452. lpImgInfoStr->compression=ICS_RLE16;
  453. break;
  454. case 24:
  455. lpImgInfoStr->compression=ICS_RLE24;
  456. break;
  457. case 32:
  458. lpImgInfoStr->compression=ICS_RLE32;
  459. break;
  460. default:
  461. file.Close();
  462. pInfo->result=ER_BADIMAGE;
  463. return;
  464. }
  465. break;
  466. default:
  467. file.Close();
  468. pInfo->result=ER_BADIMAGE;
  469. return;
  470. }
  474. // 每一图像行所占的字节数（DWORD对齐，并且只对非压缩位图有效）
  475. lpImgInfoStr->linesize = DIBSCANLINE_WIDTHBYTES(tgaHeader.wWidth*tgaHeader.bBits);
  477. lpImgInfoStr->imgnumbers = 1; // TGA文件中只有一个图像
  478. //应当还有原始图象缩图(Postage Stamp)
  479. //但晓月儿还未遇见实例
  481. lpImgInfoStr->imgchang = 0; // 表示可以被编辑
  483. // 获取文件最后的修改日期（月在高字节，日在低字节）
  484. file.GetStatus(status);
  485. lpImgInfoStr->year = (WORD)status.m_mtime.GetYear();
  486. lpImgInfoStr->monday = (WORD)status.m_mtime.GetMonth();
  487. lpImgInfoStr->monday <<= 8;
  488. lpImgInfoStr->monday |= (WORD)status.m_mtime.GetDay();
  490. // 获取文件最后的修改时间（字序：最高—0, 2—时，1—分，0—秒）
  491. lpImgInfoStr->time = status.m_mtime.GetHour();
  492. lpImgInfoStr->time <<= 8;
  493. lpImgInfoStr->time |= status.m_mtime.GetMinute();
  494. lpImgInfoStr->time <<= 8;
  495. lpImgInfoStr->time |= status.m_mtime.GetSecond();
  496. lpImgInfoStr->time &= 0xffffff;
  499. file.Close();
  501. // 设置出口数据
  502. pInfo->state = PKST_PASSINFO;
  503. pInfo->result = ER_SUCCESS;
  504. }
  510. BOOL IsFileExist(char *lpFileName)
  511. {
  512. CFile file;
  513. BOOL bExist = FALSE; // 文件存在是TRUE，不存在是FALSE
  514. CFileException e;
  516. // 确定指定的文件是否存在
  517. if (file.Open(lpFileName, CFile::modeReadWrite|CFile::shareDenyNone, &e))
  518. {
  519. bExist = TRUE;
  520. file.Close();
  521. }
  522. else
  523. {
  524. // 可能有其他程序正在处理此文件
  525. switch(e.m_cause)
  526. {
  527. case CFileException::tooManyOpenFiles:
  528. case CFileException::accessDenied:
  529. case CFileException::sharingViolation:
  530. case CFileException::lockViolation:
  531. return TRUE;
  532. case CFileException::fileNotFound:
  533. case CFileException::badPath:
  534. case CFileException::invalidFile:
  535. case CFileException::hardIO:
  536. default:
  537. return FALSE;
  538. }
  539. }
  541. return bExist;
  542. }
  544. // 操作命令解释函数---解释：CMD_LOAD_FROM_FILE命令
  545. // 从指定图像文件中读取数据
  546. void _fnCMD_LOAD_FROM_FILE(INFOSTR *pInfo)
  547. {
  548. // 检验入口参数是否符合接口定义
  549. ASSERT(pInfo->result == ER_EMPTY);
  550. ASSERT(::strlen(pInfo->filename));
  551. // 此时，该文件必需是一个已存在的、有效的TGA文件，并且数据包中
  552. // 含有该文件的信息（imginfo结构中）
  553. ASSERT(pInfo->state == PKST_PASSINFO);
  554. ASSERT(pInfo->imginfo.imgformat == IMF_TGA);
  555. ASSERT(pInfo->pImgInfo == NULL);
  556. // 必需设置标准图像格式信息
  557. ASSERT(pInfo->sDIBInfo.bmi.biSize == sizeof(BITMAPINFOHEADER));
  558. ASSERT(pInfo->pLineAddr != NULL);
  559. ASSERT(pInfo->_pbdata != NULL);
  561. CFile file;
  563. if (pInfo->fpProgress)
  564. {
  565. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, 6))
  566. { // 如果进度函数返回1，则说明用户想中断操作，返回。
  567. pInfo->result = ER_USERBREAK;
  568. return;
  569. }
  570. }
  572. // 打开指定文件
  573. if (!file.Open(pInfo->filename, CFile::modeRead))
  574. {
  575. pInfo->result = ER_FILERWERR;
  576. return;
  577. }
  578. file.Seek(0, CFile::begin);
  580. // 读取并转换图像到数据包中
  581. if (_Read(file, pInfo) == 0)
  582. {
  583. // 成功
  584. pInfo->state = PKST_INFOANDBITS;
  585. pInfo->modify = 0;
  586. pInfo->result = ER_SUCCESS;
  587. }
  589. file.Close();
  591. if (pInfo->fpProgress) // 结束进度条，此调用不再支持用户中断
  592. (*pInfo->fpProgress)(RWPROGRESSSIZE, RWPROGRESSSIZE);
  594. }
  596. int _Read(CFile& file, LPINFOSTR pInfo)
  597. {
  600. DWORD dwSize, dwRet;
  601. UINT uRet,uRet1;
  602. /******************************/
  604. TGAHEADER tgaHeader;
  605. BYTE pPal[768];
  606. PBYTE pTempPal,pImage;
  607. WORD wPalLen=0;//调色板长度(In Byte)
  608. DWORD dwOffBits;
  609. BOOL bGray;
  610. /* 读取TGA的文件头结构 */
  611. file.SeekToBegin();
  612. uRet = file.Read(&tgaHeader, sizeof(TGAHEADER));
  613. uRet1 = file.Seek(tgaHeader.bID_Length,CFile::current);
  614. if ((uRet != sizeof(TGAHEADER))||uRet1!=uRet+tgaHeader.bID_Length)
  615. {
  616. pInfo->result = ER_FILERWERR;
  617. return 1; // 读文件时出错
  618. }
  621. bGray=(tgaHeader.bImageType==TGA_UNCPSGRAY||tgaHeader.bImageType==TGA_RLEGRAY)?TRUE:FALSE;//判断灰度图象
  622. memset(pPal,0,sizeof(pPal));
  623. // pPal将包含调色板信息（如果有的话）
  624. if(tgaHeader.bPalType||tgaHeader.bImageType==TGA_UNCPSPAL||tgaHeader.bImageType==TGA_RLEPAL)
  625. {
  627. wPalLen=tgaHeader.wPalLength*((tgaHeader.bPalBits+7)>>3);
  628. pTempPal = (PBYTE)::GlobalAlloc(GPTR, wPalLen);
  629. if (pTempPal == NULL)
  630. {
  631. pInfo->result = ER_MEMORYERR;
  632. return 2; // 内存不足
  633. }
  635. // 读取位图文件的原始信息
  636. uRet = file.Read(pTempPal, wPalLen);
  637. if (uRet != wPalLen)
  638. {
  639. ::GlobalFree(pTempPal);
  640. pInfo->result = ER_FILERWERR;
  641. return 1;
  642. }
  644. int i,fstIndex=tgaHeader.wPalFirstNdx*3;
  645. WORD wPalEntry;
  647. switch(tgaHeader.bPalBits)
  648. {
  649. case 15:
  650. case 16:
  651. for(i=0;i<wPalLen;i+=2)
  652. {
  653. wPalEntry=*((WORD*)(pTempPal+i));
  654. pPal[fstIndex++]=(wPalEntry&0x1f)<<3;
  655. pPal[fstIndex++]=((wPalEntry>>5)&0x1f)<<3;
  656. pPal[fstIndex++]=((wPalEntry>>10)&0x1f)<<3;
  657. }
  658. break;
  659. case 24:
  660. memcpy(pPal+fstIndex,pTempPal,wPalLen);
  661. break;
  662. case 32:
  663. for(i=0;i<wPalLen;i+=4,fstIndex+=3)
  664. memcpy(pPal+fstIndex,pTempPal+i,3);
  665. break;
  666. default:
  667. ::GlobalFree(pTempPal);
  668. pInfo->result=ER_BADIMAGE;
  669. return -1;
  670. break;
  671. }
  672. ::GlobalFree(pTempPal);
  673. }//End 读取调色板
  674. else
  675. if(bGray)//灰度
  676. {
  677. for(int i=0;i<256;i++)
  678. memset(pPal+i*3,(char)i,3);
  679. }
  682. // 获取文件长度
  683. dwSize = file.GetLength();
  684. dwOffBits=sizeof(TGAHEADER)+tgaHeader.bID_Length+wPalLen;
  685. // 分配内存，用于存放位数据
  686. pImage = (PBYTE)::GlobalAlloc(GPTR, dwSize-dwOffBits);
  687. if (!pImage)
  688. {
  689. pInfo->result = ER_MEMORYERR;
  690. return 2; // 内存不足
  691. }
  693. // 读取位数据
  694. file.Seek(dwOffBits, CFile::begin);
  695. dwRet = file.ReadHuge((void*)pImage,dwSize-dwOffBits);
  697. if (dwRet != (dwSize-dwOffBits))//还应判断是否小于最小字节数
  698. {
  699. ::GlobalFree(pImage);
  700. pInfo->result = ER_FILERWERR;
  701. return 1;
  702. }
  707. int result = 0; // 接收各函数的返回值
  709. // 根据位图文件的位深度的不同而调用相应的读取函数
  710. switch(tgaHeader.bImageType)
  711. {
  712. case TGA_UNCPSPAL:
  713. case TGA_UNCPSGRAY:
  714. switch(tgaHeader.bBits)
  715. {
  716. case 8:
  717. result = _from_8_PAL_read(pInfo, pImage,tgaHeader, pPal);
  718. break;
  719. default: //使用调色板的位图索引一般只有8位
  720. result=-1;
  721. break;
  722. }
  723. break;
  724. case TGA_UNCPSCOLOR:
  725. switch(tgaHeader.bBits)
  726. {
  727. case 15:
  728. case 16:
  729. result=_from_15_16_COLOR_read(pInfo,pImage,tgaHeader);
  730. break;
  731. case 24:
  732. result=_from_24_COLOR_read(pInfo,pImage,tgaHeader);
  733. break;
  734. case 32:
  735. result=_from_32_COLOR_read(pInfo,pImage,tgaHeader);
  736. break;
  737. default:
  738. result=-1;//全彩图象素位长应当只有 15,16,24,32几种
  739. break;
  740. }
  741. break;
  742. case TGA_RLEGRAY:
  743. case TGA_RLEPAL:
  744. switch(tgaHeader.bBits)
  745. {
  746. case 8:
  747. result=_from_8_RLE_PAL_read(pInfo,pImage,tgaHeader,pPal);
  748. break;
  749. default:
  750. result=-1;
  751. break;
  752. }
  753. break;
  754. case TGA_RLECOLOR:
  755. switch(tgaHeader.bBits)
  756. {
  757. case 15:
  758. case 16:
  759. result=_from_15_16_RLE_COLOR_read(pInfo,pImage,tgaHeader);
  760. break;
  761. case 24:
  762. result=_from_24_RLE_COLOR_read(pInfo,pImage,tgaHeader);
  763. break;
  764. case 32:
  765. result=_from_32_RLE_COLOR_read(pInfo,pImage,tgaHeader);
  766. break;
  767. default:
  768. result=-1;//全彩图象素位长应当只有 15,16,24,32几种
  769. break;
  770. }
  771. break;
  772. default:
  773. result=-1;
  774. break; // 图像文件格式异常
  775. }
  777. // 释放从文件中读取的位数据（此数据已被转换并保存到了数据包中）
  778. ::GlobalFree(pImage);
  780. if (result == 0) // 执行成功
  781. {
  782. pInfo->result = ER_SUCCESS;
  783. }
  784. else
  785. {
  787. if(pInfo->result==ER_EMPTY)//没有调用read函数
  788. pInfo->result=ER_BADIMAGE;//文件格式非法
  789. pInfo->pImgInfo = NULL;
  790. return 4; // 执行过程中产生的错误，详见pInfo->result
  791. }
  793. return 0;
  794. }
  796. int _from_8_PAL_read(LPINFOSTR pInfo, PBYTE lpSrc, const TGAHEADER& tgaHeader, const LPBYTE pPal)//Passed
  797. {
  799. ASSERT(pInfo);
  800. ASSERT(lpSrc);
  801. ASSERT(tgaHeader.bBits==8);//前提
  802. ASSERT(pPal);
  803. LPBITMAPINFOHEADER pBmpInfo=&(pInfo->sDIBInfo.bmi);
  805. WORD wSrcBytesPerLine=DIBSCANLINE_WIDTHBYTES(tgaHeader.wWidth*8);
  806. DWORD*(*pDestLineAddr)=pInfo->pLineAddr;
  808. LPBYTE pSrcBuf,pDest24;
  809. LPWORD pDest16;
  810. DESFORMAT fmt=::_get_desformat(pInfo);
  811. int iRow,iCol;
  813. switch(fmt)
  814. {
  815. case DF_32:
  816. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  817. {
  818. if(tgaHeader.bDescriptor&TGA_VERTMIRROR) //上下倒置
  819. pSrcBuf=lpSrc+wSrcBytesPerLine*iRow;
  820. else
  821. pSrcBuf=lpSrc+wSrcBytesPerLine*(pBmpInfo->biHeight-1-iRow);
  824. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  825. {
  826. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  827. memcpy(pDestLineAddr[iRow]+iCol,pPal+pSrcBuf[pBmpInfo->biWidth-1-iCol]*3,3);
  828. else
  829. memcpy(pDestLineAddr[iRow]+iCol,pPal+pSrcBuf[iCol]*3,3);
  830. }
  831. }
  832. break;
  833. case DF_24:
  834. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  835. {
  836. if(tgaHeader.bDescriptor&TGA_VERTMIRROR) //上下倒置
  837. pSrcBuf=lpSrc+wSrcBytesPerLine*iRow;
  838. else
  839. pSrcBuf=lpSrc+wSrcBytesPerLine*(pBmpInfo->biHeight-1-iRow);
  841. pDest24=(LPBYTE)pDestLineAddr[iRow];
  842. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  843. {
  844. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  845. memcpy(pDest24+iCol*3,pPal+pSrcBuf[pBmpInfo->biWidth-1-iCol]*3,3);
  846. else
  847. memcpy(pDest24+iCol*3,pPal+pSrcBuf[iCol]*3,3);
  848. }
  849. }
  850. break;
  851. case DF_16_555:
  852. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  853. {
  854. if(tgaHeader.bDescriptor&TGA_VERTMIRROR) //上下倒置
  855. pSrcBuf=lpSrc+wSrcBytesPerLine*iRow;
  856. else
  857. pSrcBuf=lpSrc+wSrcBytesPerLine*(pBmpInfo->biHeight-1-iRow);
  859. pDest16=(LPWORD)pDestLineAddr[iRow];
  860. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  861. {
  862. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  863. pDest16[iCol]=::_cnv_rgb_to_555(pPal[pSrcBuf[pBmpInfo->biWidth-1-iCol]*3+2],pPal[pSrcBuf[pBmpInfo->biWidth-1-iCol]*3+1],pPal[pSrcBuf[pBmpInfo->biWidth-1-iCol]*3]);
  864. else
  865. pDest16[iCol]=::_cnv_rgb_to_555(pPal[pSrcBuf[iCol]*3+2],pPal[pSrcBuf[iCol]*3+1],pPal[pSrcBuf[iCol]*3]);
  866. }
  867. }
  868. break;
  869. case DF_16_565:
  870. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  871. {
  872. if(tgaHeader.bDescriptor&TGA_VERTMIRROR) //上下倒置
  873. pSrcBuf=lpSrc+wSrcBytesPerLine*iRow;
  874. else
  875. pSrcBuf=lpSrc+wSrcBytesPerLine*(pBmpInfo->biHeight-1-iRow);
  877. pDest16=(LPWORD)pDestLineAddr[iRow];
  878. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  879. {
  880. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  881. pDest16[iCol]=::_cnv_rgb_to_565(pPal[pSrcBuf[pBmpInfo->biWidth-1-iCol]*3+2],pPal[pSrcBuf[pBmpInfo->biWidth-1-iCol]*3+1],pPal[pSrcBuf[pBmpInfo->biWidth-1-iCol]*3]);
  882. else
  883. pDest16[iCol]=::_cnv_rgb_to_565(pPal[pSrcBuf[iCol]*3+2],pPal[pSrcBuf[iCol]*3+1],pPal[pSrcBuf[iCol]*3]);
  884. }
  885. }
  886. break;
  887. case DF_NULL:
  888. default:
  889. ASSERT(FALSE);
  890. pInfo->result = ER_ILLCOMM;
  891. return -1;
  892. break;
  893. }
  895. return 0;
  897. }
  899. int _from_15_16_COLOR_read(LPINFOSTR pInfo, PBYTE lpSrc, const TGAHEADER& tgaHeader)//Passed
  900. {
  901. ASSERT(pInfo);
  902. ASSERT(lpSrc);
  903. ASSERT(tgaHeader.bBits==15||tgaHeader.bBits==16);//前提
  904. LPBITMAPINFOHEADER pBmpInfo=&(pInfo->sDIBInfo.bmi);
  906. WORD wSrcBytesPerLine=DIBSCANLINE_WIDTHBYTES(tgaHeader.wWidth*16);
  907. DWORD*(*pDestLineAddr)=pInfo->pLineAddr;
  908. LPBYTE pSrcBuf,pDest24;
  909. BYTE bB,bG,bR;
  910. WORD wTempCol;
  911. LPWORD pDest16;
  912. DESFORMAT fmt=::_get_desformat(pInfo);
  913. int iRow,iCol;
  916. switch(fmt)
  917. {
  918. case DF_32:
  919. //应该先将目标数据区清零否??
  920. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  921. {
  922. if(tgaHeader.bDescriptor&TGA_VERTMIRROR) //上下倒置
  923. pSrcBuf=lpSrc+wSrcBytesPerLine*iRow;
  924. else
  925. pSrcBuf=lpSrc+wSrcBytesPerLine*(pBmpInfo->biHeight-1-iRow);
  928. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  929. {
  930. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  931. wTempCol=*((WORD*)(pSrcBuf+(pBmpInfo->biWidth-1-iCol)*2));
  932. else
  933. wTempCol=*((WORD*)(pSrcBuf+iCol*2));
  935. bB=(wTempCol&0x1f)<<3;
  936. bG=((wTempCol>>5)&0x1f)<<3;
  937. bR=((wTempCol>>10)&0x1f)<<3;
  938. pDestLineAddr[iRow][iCol]=BGR(bB,bG,bR);
  939. }
  940. }
  941. break;
  942. case DF_24:
  943. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  944. {
  945. if(tgaHeader.bDescriptor&TGA_VERTMIRROR) //上下倒置
  946. pSrcBuf=lpSrc+wSrcBytesPerLine*iRow;
  947. else
  948. pSrcBuf=lpSrc+wSrcBytesPerLine*(pBmpInfo->biHeight-1-iRow);
  950. pDest24=(LPBYTE)pDestLineAddr[iRow];
  952. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  953. {
  954. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  955. wTempCol=*((WORD*)(pSrcBuf+(pBmpInfo->biWidth-1-iCol)*2));
  956. else
  957. wTempCol=*((WORD*)(pSrcBuf+iCol*2));
  959. pDest24[iCol*3]=(wTempCol&0x1f)<<3;
  960. pDest24[iCol*3+1]=((wTempCol>>5)&0x1f)<<3;
  961. pDest24[iCol*3+2]=((wTempCol>>10)&0x1f)<<3;
  962. }
  963. }
  964. break;
  965. case DF_16_555:
  966. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  967. {
  968. if(tgaHeader.bDescriptor&TGA_VERTMIRROR) //上下倒置
  969. pSrcBuf=lpSrc+wSrcBytesPerLine*iRow;
  970. else
  971. pSrcBuf=lpSrc+wSrcBytesPerLine*(pBmpInfo->biHeight-1-iRow);
  973. pDest16=(LPWORD)pDestLineAddr[iRow];
  975. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  976. {
  977. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  978. pDest16[iCol]=*((WORD*)(pSrcBuf+(pBmpInfo->biWidth-1-iCol)*2));
  979. else
  980. pDest16[iCol]=*((WORD*)(pSrcBuf+iCol*2));
  982. }
  983. }
  984. break;
  985. case DF_16_565:
  986. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  987. {
  988. if(tgaHeader.bDescriptor&TGA_VERTMIRROR) //上下倒置
  989. pSrcBuf=lpSrc+wSrcBytesPerLine*iRow;
  990. else
  991. pSrcBuf=lpSrc+wSrcBytesPerLine*(pBmpInfo->biHeight-1-iRow);
  993. pDest16=(LPWORD)pDestLineAddr[iRow];
  994. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  995. {
  996. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  997. wTempCol=*((WORD*)(pSrcBuf+(pBmpInfo->biWidth-1-iCol)*2));
  998. else
  999. wTempCol=*((WORD*)(pSrcBuf+iCol*2));
  1001. bB=(wTempCol&0x1f)<<3;
  1002. bG=((wTempCol>>5)&0x1f)<<3;
  1003. bR=((wTempCol>>10)&0x1f)<<3;
  1004. pDest16[iCol]=::_cnv_rgb_to_565(bR,bG,bB);
  1005. }
  1006. }
  1007. break;
  1008. case DF_NULL:
  1009. default:
  1010. ASSERT(FALSE);
  1011. pInfo->result = ER_ILLCOMM;
  1012. return -1;
  1013. break;
  1014. }
  1015. return 0;
  1016. }
  1018. int _from_24_COLOR_read(LPINFOSTR pInfo, PBYTE lpSrc, const TGAHEADER& tgaHeader)//Passed
  1019. {
  1020. ASSERT(pInfo);
  1021. ASSERT(lpSrc);
  1022. ASSERT(tgaHeader.bBits==24);//前提
  1023. LPBITMAPINFOHEADER pBmpInfo=&(pInfo->sDIBInfo.bmi);
  1025. WORD wSrcBytesPerLine=DIBSCANLINE_WIDTHBYTES(tgaHeader.wWidth*24);
  1026. DWORD*(*pDestLineAddr)=pInfo->pLineAddr;
  1027. LPBYTE pSrcBuf;
  1028. DESFORMAT fmt=::_get_desformat(pInfo);
  1029. int iRow,iCol;
  1030. LPBYTE pDest24;
  1031. LPWORD pDest16;
  1033. switch(fmt)
  1034. {
  1035. case DF_32:
  1036. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1037. {
  1038. if(tgaHeader.bDescriptor&TGA_VERTMIRROR) //上下倒置
  1039. pSrcBuf=lpSrc+wSrcBytesPerLine*iRow;
  1040. else
  1041. pSrcBuf=lpSrc+wSrcBytesPerLine*(pBmpInfo->biHeight-1-iRow);
  1044. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1045. {
  1046. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1047. memcpy(pDestLineAddr[iRow]+iCol,pSrcBuf+(pBmpInfo->biWidth-1-iCol)*3,3);
  1048. else
  1049. memcpy(pDestLineAddr[iRow]+iCol,pSrcBuf+iCol*3,3);
  1050. }
  1051. }
  1052. break;
  1053. case DF_24:
  1054. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1055. {
  1056. if(tgaHeader.bDescriptor&TGA_VERTMIRROR) //上下倒置
  1057. pSrcBuf=lpSrc+wSrcBytesPerLine*iRow;
  1058. else
  1059. pSrcBuf=lpSrc+wSrcBytesPerLine*(pBmpInfo->biHeight-1-iRow);
  1061. pDest24=(LPBYTE)pDestLineAddr[iRow];
  1063. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1064. {
  1065. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1066. memcpy(pDest24+iCol*3,pSrcBuf+(pBmpInfo->biWidth-1-iCol)*3,3);
  1067. else
  1068. memcpy(pDest24+iCol*3,pSrcBuf+iCol*3,3);
  1069. }
  1070. }
  1071. break;
  1072. case DF_16_555:
  1073. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1074. {
  1075. if(tgaHeader.bDescriptor&TGA_VERTMIRROR) //上下倒置
  1076. pSrcBuf=lpSrc+wSrcBytesPerLine*iRow;
  1077. else
  1078. pSrcBuf=lpSrc+wSrcBytesPerLine*(pBmpInfo->biHeight-1-iRow);
  1080. pDest16=(LPWORD)pDestLineAddr[iRow];
  1082. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1083. {
  1084. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1085. pDest16[iCol]=::_cnv_rgb_to_555(pSrcBuf[(pBmpInfo->biWidth-1-iCol)*3+2],pSrcBuf[(pBmpInfo->biWidth-1-iCol)*3+1],pSrcBuf[(pBmpInfo->biWidth-1-iCol)*3]);
  1086. else
  1087. pDest16[iCol]=::_cnv_rgb_to_555(pSrcBuf[iCol*3+2],pSrcBuf[iCol*3+1],pSrcBuf[iCol*3]);
  1088. }
  1089. }
  1090. break;
  1091. case DF_16_565:
  1092. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1093. {
  1094. if(tgaHeader.bDescriptor&TGA_VERTMIRROR) //上下倒置
  1095. pSrcBuf=lpSrc+wSrcBytesPerLine*iRow;
  1096. else
  1097. pSrcBuf=lpSrc+wSrcBytesPerLine*(pBmpInfo->biHeight-1-iRow);
  1099. pDest16=(LPWORD)pDestLineAddr[iRow];
  1101. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1102. {
  1103. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1104. pDest16[iCol]=::_cnv_rgb_to_565(pSrcBuf[(pBmpInfo->biWidth-1-iCol)*3+2],pSrcBuf[(pBmpInfo->biWidth-1-iCol)*3+1],pSrcBuf[(pBmpInfo->biWidth-1-iCol)*3]);
  1105. else
  1106. pDest16[iCol]=::_cnv_rgb_to_565(pSrcBuf[iCol*3+2],pSrcBuf[iCol*3+1],pSrcBuf[iCol*3]);
  1107. }
  1108. }
  1109. break;
  1110. case DF_NULL:
  1111. default:
  1112. ASSERT(FALSE);
  1113. pInfo->result = ER_ILLCOMM;
  1114. return -1;
  1115. break;
  1116. }
  1117. return 0;
  1118. }
  1120. int _from_32_COLOR_read(LPINFOSTR pInfo, PBYTE lpSrc, const TGAHEADER& tgaHeader)//Passed
  1121. {
  1122. ASSERT(pInfo);
  1123. ASSERT(lpSrc);
  1124. ASSERT(tgaHeader.bBits==32);//前提
  1125. LPBITMAPINFOHEADER pBmpInfo=&(pInfo->sDIBInfo.bmi);
  1127. WORD wSrcBytesPerLine=DIBSCANLINE_WIDTHBYTES(tgaHeader.wWidth*32);
  1128. DWORD*(*pDestLineAddr)=pInfo->pLineAddr;
  1129. LPBYTE pSrcBuf;
  1131. DESFORMAT fmt=::_get_desformat(pInfo);
  1132. int iRow,iCol;
  1133. LPBYTE pDest24;
  1134. LPWORD pDest16;
  1136. //应该先将目标数据区清零否??
  1137. switch(fmt)
  1138. {
  1139. case DF_32:
  1140. for( iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1141. {
  1142. if(tgaHeader.bDescriptor&TGA_VERTMIRROR) //上下倒置
  1143. pSrcBuf=lpSrc+wSrcBytesPerLine*iRow;
  1144. else
  1145. pSrcBuf=lpSrc+wSrcBytesPerLine*(pBmpInfo->biHeight-1-iRow);
  1148. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1149. {
  1150. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1151. memcpy(pDestLineAddr[iRow]+iCol,pSrcBuf+(pBmpInfo->biWidth-1-iCol)*4,3);
  1152. else
  1153. memcpy(pDestLineAddr[iRow]+iCol,pSrcBuf+iCol*4,3);
  1154. }
  1155. }
  1156. break;
  1157. case DF_24:
  1158. for( iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1159. {
  1160. if(tgaHeader.bDescriptor&TGA_VERTMIRROR) //上下倒置
  1161. pSrcBuf=lpSrc+wSrcBytesPerLine*iRow;
  1162. else
  1163. pSrcBuf=lpSrc+wSrcBytesPerLine*(pBmpInfo->biHeight-1-iRow);
  1165. pDest24=(LPBYTE)pDestLineAddr[iRow];
  1167. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1168. {
  1169. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1170. memcpy(pDest24+iCol*3,pSrcBuf+(pBmpInfo->biWidth-1-iCol)*4,3);
  1171. else
  1172. memcpy(pDest24+iCol*3,pSrcBuf+iCol*4,3);
  1173. }
  1174. }
  1175. break;
  1176. case DF_16_555:
  1177. for( iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1178. {
  1179. if(tgaHeader.bDescriptor&TGA_VERTMIRROR) //上下倒置
  1180. pSrcBuf=lpSrc+wSrcBytesPerLine*iRow;
  1181. else
  1182. pSrcBuf=lpSrc+wSrcBytesPerLine*(pBmpInfo->biHeight-1-iRow);
  1184. pDest16=(LPWORD)pDestLineAddr[iRow];
  1186. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1187. {
  1188. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1189. pDest16[iCol]=::_cnv_rgb_to_555(pSrcBuf[(pBmpInfo->biWidth-1-iCol)*4+2],pSrcBuf[(pBmpInfo->biWidth-1-iCol)*4+1],pSrcBuf[(pBmpInfo->biWidth-1-iCol)*4]);
  1190. else
  1191. pDest16[iCol]=::_cnv_rgb_to_555(pSrcBuf[iCol*4+2],pSrcBuf[iCol*4+1],pSrcBuf[iCol*4]);
  1192. }
  1193. }
  1194. break;
  1195. case DF_16_565:
  1196. for( iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1197. {
  1198. if(tgaHeader.bDescriptor&TGA_VERTMIRROR) //上下倒置
  1199. pSrcBuf=lpSrc+wSrcBytesPerLine*iRow;
  1200. else
  1201. pSrcBuf=lpSrc+wSrcBytesPerLine*(pBmpInfo->biHeight-1-iRow);
  1203. pDest16=(LPWORD)pDestLineAddr[iRow];
  1205. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1206. {
  1207. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1208. pDest16[iCol]=::_cnv_rgb_to_565(pSrcBuf[(pBmpInfo->biWidth-1-iCol)*4+2],pSrcBuf[(pBmpInfo->biWidth-1-iCol)*4+1],pSrcBuf[(pBmpInfo->biWidth-1-iCol)*4]);
  1209. else
  1210. pDest16[iCol]=::_cnv_rgb_to_565(pSrcBuf[iCol*4+2],pSrcBuf[iCol*4+1],pSrcBuf[iCol*4]);
  1211. }
  1212. }
  1213. break;
  1214. case DF_NULL:
  1215. default:
  1216. ASSERT(FALSE);
  1217. pInfo->result = ER_ILLCOMM;
  1218. return -1;
  1219. break;
  1220. }
  1221. return 0;
  1222. }
  1224. //行解压
  1225. int DecodingLine(BYTE *pDest,BYTE* pSrc,int rleunit,int destlen)//返回pDest实际解压字节数
  1226. {
  1227. ASSERT(pSrc);
  1228. ASSERT(pDest);
  1230. int iCol,nCount;
  1231. BYTE *pDestEnd=pDest+destlen,*pSrcOrg=pSrc,*pDestOrg=pDest;
  1232. for(;pDest<pDestEnd;)
  1233. {
  1234. if(pSrc[0]&0x80)
  1235. {
  1236. nCount=(pSrc[0]&0x7F)+1;
  1237. pSrc++;
  1238. for(iCol=0;iCol<nCount;iCol++)
  1239. {
  1240. memcpy(pDest,pSrc,rleunit);
  1241. pDest+=rleunit;
  1242. }
  1243. pSrc+=rleunit;
  1244. }
  1245. else
  1246. {
  1247. nCount=(pSrc[0]&0x7F)+1;
  1248. pSrc++;
  1249. memcpy(pDest,pSrc,nCount*rleunit);
  1250. pDest+=nCount*rleunit;
  1251. pSrc+=nCount*rleunit;
  1252. }
  1254. }
  1255. #ifdef _OVERCHECK
  1256. if(pDest-pDestOrg!=destlen)
  1257. return -1;
  1258. #endif
  1259. return pSrc-pSrcOrg;
  1260. }
  1262. //解压缩最后还应判断数据是否越界(即被解出之数据量大于原数据)
  1263. int _from_8_RLE_PAL_read(LPINFOSTR pInfo, PBYTE lpSrc, const TGAHEADER& tgaHeader, const LPBYTE pPal)//Passed
  1264. {
  1265. ASSERT(pInfo);
  1266. ASSERT(lpSrc);
  1267. ASSERT(tgaHeader.bBits==8);//前提
  1268. ASSERT(pPal);
  1269. LPBITMAPINFOHEADER pBmpInfo=&(pInfo->sDIBInfo.bmi);
  1271. WORD wSrcBytesPerLine=DIBSCANLINE_WIDTHBYTES(tgaHeader.wWidth*8);
  1272. DWORD*(*pDestLineAddr)=pInfo->pLineAddr;
  1274. LPBYTE pTempBuf;//解压缓存
  1275. int iDecoded;
  1276. pTempBuf=(LPBYTE)::GlobalAlloc(GPTR,wSrcBytesPerLine+128*1);
  1278. if(!pTempBuf)
  1279. {
  1280. pInfo->result=ER_MEMORYERR;
  1281. return -1;
  1282. }
  1284. LPBYTE pDest24;
  1285. LPWORD pDest16;
  1287. DESFORMAT fmt=::_get_desformat(pInfo);
  1288. int iRow,iCol;
  1290. switch(fmt)
  1291. {
  1292. case DF_32:
  1293. //应该先将目标数据区清零否??
  1294. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1295. {
  1296. iDecoded=::DecodingLine(pTempBuf,lpSrc,1,wSrcBytesPerLine);
  1297. if(iDecoded==-1)
  1298. {
  1299. GlobalFree(pTempBuf);
  1300. pInfo->result=ER_BADIMAGE;
  1301. return -1;
  1302. }
  1304. lpSrc+=iDecoded;
  1306. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1307. {
  1308. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1309. {
  1310. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)//上下倒置
  1311. memcpy(pDestLineAddr[iRow]+iCol,pPal+pTempBuf[pBmpInfo->biWidth-1-iCol]*3,3);
  1312. else
  1313. memcpy(pDestLineAddr[pBmpInfo->biHeight-1-iRow]+iCol,pPal+pTempBuf[pBmpInfo->biWidth-1-iCol]*3,3);
  1315. }
  1316. else
  1317. {
  1318. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)//上下倒置
  1319. memcpy(pDestLineAddr[iRow]+iCol,pPal+pTempBuf[iCol]*3,3);
  1320. else
  1321. memcpy(pDestLineAddr[pBmpInfo->biHeight-1-iRow]+iCol,pPal+pTempBuf[iCol]*3,3);
  1323. }
  1324. }
  1325. }
  1326. break;
  1327. case DF_24:
  1328. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1329. {
  1330. iDecoded=::DecodingLine(pTempBuf,lpSrc,1,wSrcBytesPerLine);
  1331. if(iDecoded==-1)
  1332. {
  1333. GlobalFree(pTempBuf);
  1334. pInfo->result=ER_BADIMAGE;
  1335. return -1;
  1336. }
  1338. lpSrc+=iDecoded;
  1340. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)
  1341. pDest24=(LPBYTE)pDestLineAddr[iRow];
  1342. else
  1343. pDest24=(LPBYTE)pDestLineAddr[pBmpInfo->biHeight-1-iRow];
  1345. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1346. {
  1347. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1348. memcpy(pDest24+iCol*3,pPal+pTempBuf[pBmpInfo->biWidth-1-iCol]*3,3);
  1349. else
  1350. memcpy(pDest24+iCol*3,pPal+pTempBuf[iCol]*3,3);
  1351. }
  1352. }
  1353. break;
  1354. case DF_16_555:
  1355. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1356. {
  1357. iDecoded=::DecodingLine(pTempBuf,lpSrc,1,wSrcBytesPerLine);
  1358. if(iDecoded==-1)
  1359. {
  1360. GlobalFree(pTempBuf);
  1361. pInfo->result=ER_BADIMAGE;
  1362. return -1;
  1363. }
  1365. lpSrc+=iDecoded;
  1367. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)
  1368. pDest16=(LPWORD)pDestLineAddr[iRow];
  1369. else
  1370. pDest16=(LPWORD)pDestLineAddr[pBmpInfo->biHeight-1-iRow];
  1372. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1373. {
  1374. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1375. pDest16[iCol]=::_cnv_rgb_to_555(pPal[pTempBuf[pBmpInfo->biWidth-1-iCol]*3+2],pPal[pTempBuf[pBmpInfo->biWidth-1-iCol]*3+1],pPal[pTempBuf[pBmpInfo->biWidth-1-iCol]*3]);
  1376. else
  1377. pDest16[iCol]=::_cnv_rgb_to_555(pPal[pTempBuf[iCol]*3+2],pPal[pTempBuf[iCol]*3+1],pPal[pTempBuf[iCol]*3]);
  1378. }
  1379. }
  1380. break;
  1381. case DF_16_565:
  1382. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1383. {
  1384. iDecoded=::DecodingLine(pTempBuf,lpSrc,1,wSrcBytesPerLine);
  1385. if(iDecoded==-1)
  1386. {
  1387. GlobalFree(pTempBuf);
  1388. pInfo->result=ER_BADIMAGE;
  1389. return -1;
  1390. }
  1392. lpSrc+=iDecoded;
  1394. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)
  1395. pDest16=(LPWORD)pDestLineAddr[iRow];
  1396. else
  1397. pDest16=(LPWORD)pDestLineAddr[pBmpInfo->biHeight-1-iRow];
  1399. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1400. {
  1401. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1402. pDest16[iCol]=::_cnv_rgb_to_565(pPal[pTempBuf[pBmpInfo->biWidth-1-iCol]*3+2],pPal[pTempBuf[pBmpInfo->biWidth-1-iCol]*3+1],pPal[pTempBuf[pBmpInfo->biWidth-1-iCol]*3]);
  1403. else
  1404. pDest16[iCol]=::_cnv_rgb_to_565(pPal[pTempBuf[iCol]*3+2],pPal[pTempBuf[iCol]*3+1],pPal[pTempBuf[iCol]*3]);
  1405. }
  1406. }
  1407. break;
  1408. case DF_NULL:
  1409. default:
  1410. ::GlobalFree(pTempBuf);
  1411. ASSERT(FALSE);
  1412. pInfo->result = ER_ILLCOMM;
  1413. return -1;
  1414. break;
  1416. }
  1417. ::GlobalFree(pTempBuf);
  1418. return 0;
  1419. }
  1421. int _from_15_16_RLE_COLOR_read(LPINFOSTR pInfo,PBYTE lpSrc,const TGAHEADER& tgaHeader)//Passed
  1422. {
  1423. ASSERT(pInfo);
  1424. ASSERT(lpSrc);
  1425. ASSERT(tgaHeader.bBits==15||tgaHeader.bBits==16);//前提
  1426. LPBITMAPINFOHEADER pBmpInfo=&(pInfo->sDIBInfo.bmi);
  1428. WORD wSrcBytesPerLine=DIBSCANLINE_WIDTHBYTES(tgaHeader.wWidth*16);
  1429. DWORD*(*pDestLineAddr)=pInfo->pLineAddr;
  1430. LPBYTE pTempBuf;//解压缓存
  1431. int iDecoded;
  1432. BYTE bB,bG,bR;
  1433. WORD wTempCol;
  1435. pTempBuf=(LPBYTE)::GlobalAlloc(GPTR,wSrcBytesPerLine+128*((tgaHeader.bBits+7)/8));
  1436. if(!pTempBuf)
  1437. {
  1438. pInfo->result=ER_MEMORYERR;
  1439. return -1;
  1440. }
  1442. LPBYTE pDest24;
  1443. LPWORD pDest16;
  1445. DESFORMAT fmt=::_get_desformat(pInfo);
  1446. int iRow,iCol;
  1447. //应该先将目标数据区清零否??
  1449. switch(fmt)
  1450. {
  1451. case DF_32:
  1452. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1453. {
  1454. iDecoded=::DecodingLine(pTempBuf,lpSrc,2,wSrcBytesPerLine);
  1455. if(iDecoded==-1)
  1456. {
  1457. GlobalFree(pTempBuf);
  1458. pInfo->result=ER_BADIMAGE;
  1459. return -1;
  1460. }
  1462. lpSrc+=iDecoded;
  1464. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1465. {
  1467. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1468. wTempCol=*((WORD*)(pTempBuf+(pBmpInfo->biWidth-1-iCol)*2));
  1469. else
  1470. wTempCol=*((WORD*)(pTempBuf+iCol*2));
  1472. bB=(wTempCol&0x1f)<<3;
  1473. bG=((wTempCol>>5)&0x1f)<<3;
  1474. bR=((wTempCol>>10)&0x1f)<<3;
  1476. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)//上下倒置
  1477. pDestLineAddr[iRow][iCol]=BGR(bB,bG,bR);
  1478. else
  1479. pDestLineAddr[pBmpInfo->biHeight-iRow-1][iCol]=BGR(bB,bG,bR);
  1482. }
  1483. }
  1484. break;
  1485. case DF_24:
  1486. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1487. {
  1488. iDecoded=::DecodingLine(pTempBuf,lpSrc,2,wSrcBytesPerLine);
  1489. if(iDecoded==-1)
  1490. {
  1491. GlobalFree(pTempBuf);
  1492. pInfo->result=ER_BADIMAGE;
  1493. return -1;
  1494. }
  1496. lpSrc+=iDecoded;
  1498. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)
  1499. pDest24=(LPBYTE)pDestLineAddr[iRow];
  1500. else
  1501. pDest24=(LPBYTE)pDestLineAddr[pBmpInfo->biHeight-1-iRow];
  1503. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1504. {
  1506. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1507. wTempCol=*((WORD*)(pTempBuf+(pBmpInfo->biWidth-1-iCol)*2));
  1508. else
  1509. wTempCol=*((WORD*)(pTempBuf+iCol*2));
  1510. ::_cnv_555_to_rgb(wTempCol,pDest24+iCol*3+2,pDest24+iCol*3+1,pDest24+iCol*3);
  1511. }
  1512. }
  1513. break;
  1514. case DF_16_555:
  1515. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1516. {
  1517. iDecoded=::DecodingLine(pTempBuf,lpSrc,2,wSrcBytesPerLine);
  1518. if(iDecoded==-1)
  1519. {
  1520. GlobalFree(pTempBuf);
  1521. pInfo->result=ER_BADIMAGE;
  1522. return -1;
  1523. }
  1525. lpSrc+=iDecoded;
  1527. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)
  1528. pDest16=(LPWORD)pDestLineAddr[iRow];
  1529. else
  1530. pDest16=(LPWORD)pDestLineAddr[pBmpInfo->biHeight-1-iRow];
  1532. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1533. {
  1535. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1536. pDest16[iCol]=*((WORD*)(pTempBuf+(pBmpInfo->biWidth-1-iCol)*2));
  1537. else
  1538. pDest16[iCol]=*((WORD*)(pTempBuf+iCol*2));
  1539. }
  1540. }
  1541. break;
  1542. case DF_16_565:
  1543. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1544. {
  1545. iDecoded=::DecodingLine(pTempBuf,lpSrc,2,wSrcBytesPerLine);
  1546. if(iDecoded==-1)
  1547. {
  1548. GlobalFree(pTempBuf);
  1549. pInfo->result=ER_BADIMAGE;
  1550. return -1;
  1551. }
  1553. lpSrc+=iDecoded;
  1555. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)
  1556. pDest16=(LPWORD)pDestLineAddr[iRow];
  1557. else
  1558. pDest16=(LPWORD)pDestLineAddr[pBmpInfo->biHeight-1-iRow];
  1560. for(iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1561. {
  1563. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1564. pDest16[iCol]=::_cnv_555_to_565(*((WORD*)(pTempBuf+(pBmpInfo->biWidth-1-iCol)*2)));
  1565. else
  1566. pDest16[iCol]=::_cnv_555_to_565(*((WORD*)(pTempBuf+iCol*2)));
  1567. }
  1568. }
  1569. break;
  1570. case DF_NULL:
  1571. default:
  1572. ::GlobalFree(pTempBuf);
  1573. ASSERT(FALSE);
  1574. pInfo->result = ER_ILLCOMM;
  1575. return -1;
  1576. break;
  1578. }
  1579. ::GlobalFree(pTempBuf);
  1580. return 0;
  1581. }
  1584. int _from_24_RLE_COLOR_read(LPINFOSTR pInfo,PBYTE lpSrc,const TGAHEADER& tgaHeader)//Passed
  1585. {
  1586. ASSERT(pInfo);
  1587. ASSERT(lpSrc);
  1588. ASSERT(tgaHeader.bBits==24);//前提
  1589. LPBITMAPINFOHEADER pBmpInfo=&(pInfo->sDIBInfo.bmi);
  1591. WORD wSrcBytesPerLine=DIBSCANLINE_WIDTHBYTES(tgaHeader.wWidth*24);
  1592. DWORD*(*pDestLineAddr)=pInfo->pLineAddr;
  1593. LPBYTE pTempBuf;
  1594. int iDecoded;
  1596. pTempBuf=(LPBYTE)::GlobalAlloc(GPTR,wSrcBytesPerLine+128*3);
  1597. if(!pTempBuf)
  1598. {
  1599. pInfo->result=ER_MEMORYERR;
  1600. return -1;
  1601. }
  1603. LPBYTE pDest24;
  1604. LPWORD pDest16;
  1606. DESFORMAT fmt=::_get_desformat(pInfo);
  1607. int iRow,iCol;
  1609. switch(fmt)
  1610. {
  1611. case DF_32:
  1612. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1613. {
  1614. iDecoded=::DecodingLine(pTempBuf,lpSrc,3,wSrcBytesPerLine);
  1616. if(iDecoded==-1)
  1617. {
  1618. GlobalFree(pTempBuf);
  1619. pInfo->result=ER_BADIMAGE;
  1620. return -1;
  1621. }
  1623. lpSrc+=iDecoded;
  1625. for( iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1626. {
  1628. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1629. {
  1630. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)//上下反置
  1631. memcpy(pDestLineAddr[iRow]+iCol,pTempBuf+(pBmpInfo->biWidth-1-iCol)*3,3);
  1632. else
  1633. memcpy(pDestLineAddr[pBmpInfo->biHeight-1-iRow]+iCol,pTempBuf+(pBmpInfo->biWidth-1-iCol)*3,3);
  1635. }
  1636. else
  1637. {
  1638. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)//上下反置
  1639. memcpy(pDestLineAddr[iRow]+iCol,pTempBuf+iCol*3,3);
  1640. else
  1641. memcpy(pDestLineAddr[pBmpInfo->biHeight-1-iRow]+iCol,pTempBuf+iCol*3,3);
  1642. }
  1644. }
  1645. }
  1646. break;
  1647. case DF_24:
  1648. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1649. {
  1650. iDecoded=::DecodingLine(pTempBuf,lpSrc,3,wSrcBytesPerLine);
  1652. if(iDecoded==-1)
  1653. {
  1654. GlobalFree(pTempBuf);
  1655. pInfo->result=ER_BADIMAGE;
  1656. return -1;
  1657. }
  1659. lpSrc+=iDecoded;
  1661. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)
  1662. pDest24=(LPBYTE)pDestLineAddr[iRow];
  1663. else
  1664. pDest24=(LPBYTE)pDestLineAddr[pBmpInfo->biHeight-1-iRow];
  1666. for( iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1667. {
  1669. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1670. memcpy(pDest24+iCol*3,pTempBuf+(pBmpInfo->biWidth-1-iCol)*3,3);
  1671. else
  1672. memcpy(pDest24+iCol*3,pTempBuf+iCol*3,3);
  1673. }
  1675. }
  1676. break;
  1677. case DF_16_555:
  1678. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1679. {
  1680. iDecoded=::DecodingLine(pTempBuf,lpSrc,3,wSrcBytesPerLine);
  1682. if(iDecoded==-1)
  1683. {
  1684. GlobalFree(pTempBuf);
  1685. pInfo->result=ER_BADIMAGE;
  1686. return -1;
  1687. }
  1689. lpSrc+=iDecoded;
  1691. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)
  1692. pDest16=(LPWORD)pDestLineAddr[iRow];
  1693. else
  1694. pDest16=(LPWORD)pDestLineAddr[pBmpInfo->biHeight-1-iRow];
  1696. for( iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1697. {
  1699. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1700. pDest16[iCol]=::_cnv_rgb_to_555(pTempBuf[(pBmpInfo->biWidth-1-iCol)*3+2],pTempBuf[(pBmpInfo->biWidth-1-iCol)*3+1],pTempBuf[(pBmpInfo->biWidth-1-iCol)*3]);
  1701. else
  1702. pDest16[iCol]=::_cnv_rgb_to_555(pTempBuf[iCol*3+2],pTempBuf[iCol*3+1],pTempBuf[iCol*3]);
  1703. }
  1705. }
  1706. break;
  1707. case DF_16_565:
  1708. for(iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1709. {
  1710. iDecoded=::DecodingLine(pTempBuf,lpSrc,3,wSrcBytesPerLine);
  1712. if(iDecoded==-1)
  1713. {
  1714. GlobalFree(pTempBuf);
  1715. pInfo->result=ER_BADIMAGE;
  1716. return -1;
  1717. }
  1719. lpSrc+=iDecoded;
  1721. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)
  1722. pDest16=(LPWORD)pDestLineAddr[iRow];
  1723. else
  1724. pDest16=(LPWORD)pDestLineAddr[pBmpInfo->biHeight-1-iRow];
  1726. for( iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1727. {
  1729. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1730. pDest16[iCol]=::_cnv_rgb_to_565(pTempBuf[(pBmpInfo->biWidth-1-iCol)*3+2],pTempBuf[(pBmpInfo->biWidth-1-iCol)*3+1],pTempBuf[(pBmpInfo->biWidth-1-iCol)*3]);
  1731. else
  1732. pDest16[iCol]=::_cnv_rgb_to_565(pTempBuf[iCol*3+2],pTempBuf[iCol*3+1],pTempBuf[iCol*3]);
  1733. }
  1735. }
  1736. break;
  1737. case DF_NULL:
  1738. default:
  1739. ::GlobalFree(pTempBuf);
  1740. ASSERT(FALSE);
  1741. pInfo->result = ER_ILLCOMM;
  1742. return -1;
  1743. break;
  1746. }
  1748. ::GlobalFree(pTempBuf);
  1749. return 0;
  1750. }
  1752. int _from_32_RLE_COLOR_read(LPINFOSTR pInfo,PBYTE lpSrc,const TGAHEADER& tgaHeader)//Passed
  1753. {
  1754. ASSERT(pInfo);
  1755. ASSERT(lpSrc);
  1756. ASSERT(tgaHeader.bBits==32);//前提
  1757. LPBITMAPINFOHEADER pBmpInfo=&(pInfo->sDIBInfo.bmi);
  1759. WORD wSrcBytesPerLine=DIBSCANLINE_WIDTHBYTES(tgaHeader.wWidth*32);
  1760. DWORD*(*pDestLineAddr)=pInfo->pLineAddr;
  1761. LPBYTE pTempBuf;
  1762. int iDecoded;
  1764. pTempBuf=(LPBYTE)::GlobalAlloc(GPTR,wSrcBytesPerLine+128*4);
  1765. if(!pTempBuf)
  1766. {
  1767. pInfo->result=ER_MEMORYERR;
  1768. return -1;
  1769. }
  1771. LPBYTE pDest24;
  1772. LPWORD pDest16;
  1774. DESFORMAT fmt=::_get_desformat(pInfo);
  1775. int iRow,iCol;
  1777. switch(fmt)
  1778. {
  1779. case DF_32:
  1780. //应该先将目标数据区清零否??
  1781. for( iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1782. {
  1783. iDecoded=::DecodingLine(pTempBuf,lpSrc,4,wSrcBytesPerLine);
  1784. if(iDecoded==-1)
  1785. {
  1786. GlobalFree(pTempBuf);
  1787. pInfo->result=ER_BADIMAGE;
  1788. return -1;
  1789. }
  1791. lpSrc+=iDecoded;
  1793. for( iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1794. {
  1796. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1797. {
  1798. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)//上下反置
  1799. memcpy(pDestLineAddr[iRow]+iCol,pTempBuf+(pBmpInfo->biWidth-1-iCol)*4,3);
  1800. else
  1801. memcpy(pDestLineAddr[pBmpInfo->biHeight-1-iRow]+iCol,pTempBuf+(pBmpInfo->biWidth-1-iCol)*4,3);
  1803. }
  1804. else
  1805. {
  1806. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)//上下反置
  1807. memcpy(pDestLineAddr[iRow]+iCol,pTempBuf+iCol*4,3);
  1808. else
  1809. memcpy(pDestLineAddr[pBmpInfo->biHeight-1-iRow]+iCol,pTempBuf+iCol*4,3);
  1811. }
  1813. }
  1814. }
  1815. break;
  1816. case DF_24:
  1817. for( iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1818. {
  1819. iDecoded=::DecodingLine(pTempBuf,lpSrc,4,wSrcBytesPerLine);
  1820. if(iDecoded==-1)
  1821. {
  1822. GlobalFree(pTempBuf);
  1823. pInfo->result=ER_BADIMAGE;
  1824. return -1;
  1825. }
  1827. lpSrc+=iDecoded;
  1829. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)
  1830. pDest24=(LPBYTE)pDestLineAddr[iRow];
  1831. else
  1832. pDest24=(LPBYTE)pDestLineAddr[pBmpInfo->biHeight-1-iRow];
  1835. for( iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1836. {
  1838. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1839. memcpy(pDest24+iCol*3,pTempBuf+(pBmpInfo->biWidth-1-iCol)*4,3);
  1840. else
  1841. memcpy(pDest24+iCol*3,pTempBuf+iCol*4,3);
  1843. }
  1845. }
  1846. break;
  1847. case DF_16_555:
  1848. for( iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1849. {
  1850. iDecoded=::DecodingLine(pTempBuf,lpSrc,4,wSrcBytesPerLine);
  1851. if(iDecoded==-1)
  1852. {
  1853. GlobalFree(pTempBuf);
  1854. pInfo->result=ER_BADIMAGE;
  1855. return -1;
  1856. }
  1858. lpSrc+=iDecoded;
  1860. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)
  1861. pDest16=(LPWORD)pDestLineAddr[iRow];
  1862. else
  1863. pDest16=(LPWORD)pDestLineAddr[pBmpInfo->biHeight-1-iRow];
  1866. for( iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1867. {
  1869. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1870. pDest16[iCol]=::_cnv_rgb_to_555(pTempBuf[(pBmpInfo->biWidth-1-iCol)*4+2],pTempBuf[(pBmpInfo->biWidth-1-iCol)*4+1],pTempBuf[(pBmpInfo->biWidth-1-iCol)*4]);
  1871. else
  1872. pDest16[iCol]=::_cnv_rgb_to_555(pTempBuf[iCol*4+2],pTempBuf[iCol*4+1],pTempBuf[iCol*4]);
  1874. }
  1876. }
  1878. break;
  1879. case DF_16_565:
  1880. for( iRow=0;iRow<pBmpInfo->biHeight;iRow++)
  1881. {
  1882. iDecoded=::DecodingLine(pTempBuf,lpSrc,4,wSrcBytesPerLine);
  1883. if(iDecoded==-1)
  1884. {
  1885. GlobalFree(pTempBuf);
  1886. pInfo->result=ER_BADIMAGE;
  1887. return -1;
  1888. }
  1890. lpSrc+=iDecoded;
  1892. if(tgaHeader.bDescriptor&TGA_VERTMIRROR)
  1893. pDest16=(LPWORD)pDestLineAddr[iRow];
  1894. else
  1895. pDest16=(LPWORD)pDestLineAddr[pBmpInfo->biHeight-1-iRow];
  1898. for( iCol=0;iCol<pBmpInfo->biWidth;iCol++)
  1899. {
  1901. if(tgaHeader.bDescriptor&TGA_HORZMIRROR)//左右反置
  1902. pDest16[iCol]=::_cnv_rgb_to_565(pTempBuf[(pBmpInfo->biWidth-1-iCol)*4+2],pTempBuf[(pBmpInfo->biWidth-1-iCol)*4+1],pTempBuf[(pBmpInfo->biWidth-1-iCol)*4]);
  1903. else
  1904. pDest16[iCol]=::_cnv_rgb_to_565(pTempBuf[iCol*4+2],pTempBuf[iCol*4+1],pTempBuf[iCol*4]);
  1906. }
  1908. }
  1909. case DF_NULL:
  1910. default:
  1911. ::GlobalFree(pTempBuf);
  1912. ASSERT(FALSE);
  1913. pInfo->result = ER_ILLCOMM;
  1914. return -1;
  1915. break;
  1917. }
  1918. ::GlobalFree(pTempBuf);
  1919. return 0;
  1920. }
  1924. // 判断标准图像的位格式
  1925. DESFORMAT _get_desformat(LPINFOSTR pInfo)
  1926. {
  1927. ASSERT(pInfo);
  1928. // ASSERT(pInfo->state >= PKST_PASSVER);
  1929. ASSERT(pInfo->sDIBInfo.bmi.biPlanes == 1);
  1931. DESFORMAT result;
  1933. switch(pInfo->sDIBInfo.bmi.biBitCount)
  1934. {
  1935. case 32:
  1936. /******************************************************
  1937. 32位掩码示意图
  1938.     高               ->                 低
  1939. 0000 0000   0000 0000   0000 0000   0000 0000  888格式
  1940.             1111 1111  ------------------------R
  1941.                         1111 1111 -------------G
  1942.                                     1111 1111--B
  1943. * Win95 系统只支持这一种格式
  1944. ******************************************************/
  1945. if (pInfo->sDIBInfo.bmi.biCompression == BI_RGB)
  1946. {
  1947. result = DF_32;
  1948. break;
  1949. }
  1951. if ((pInfo->sDIBInfo.rmask == 0xff0000)&&
  1952. (pInfo->sDIBInfo.gmask == 0xff00)&&
  1953. (pInfo->sDIBInfo.bmask == 0xff))
  1954. result = DF_32;
  1955. else
  1956. {
  1957. ASSERT(FALSE); // 只支持888格式
  1958. result = DF_NULL;
  1959. }
  1960. break;
  1961. case 24:
  1962. result = DF_24;
  1963. break;
  1964. case 16:
  1965. /*******************************************
  1966. 16位掩码示意图
  1968.   高字节      低字节
  1969. 0000 0000   0000 0000 
  1970.    1 1111--B // 555格式
  1971.    11 111 -------G
  1972.  111 11  --------------R
  1973. 0
  1974.    1 1111--B // 565格式
  1975.   111   111 -------G
  1976. 1111 1   --------------R
  1978. * Win95 系统只支持以上两种格式
  1979. *******************************************/
  1980. if (pInfo->sDIBInfo.bmi.biCompression == BI_RGB)
  1981. {
  1982. result = DF_16_555;
  1983. break;
  1984. }
  1986. if ((pInfo->sDIBInfo.rmask == 0x7c00)&&
  1987. (pInfo->sDIBInfo.gmask == 0x3e0)&&
  1988. (pInfo->sDIBInfo.bmask == 0x1f))
  1989. result = DF_16_555;
  1990. else if ((pInfo->sDIBInfo.rmask == 0xf800)&&
  1991. (pInfo->sDIBInfo.gmask == 0x7e0)&&
  1992. (pInfo->sDIBInfo.bmask == 0x1f))
  1993. result = DF_16_565;
  1994. else
  1995. result = DF_NULL;
  1996. break;
  1997. default:
  1998. ASSERT(FALSE); // 不接受其它格式
  1999. result = DF_NULL;
  2000. break;
  2001. }
  2003. return result;
  2004. }
  2006. // 将指定的RGB颜色分量转换成555格式（WORD型值返回）
  2007. WORD _cnv_rgb_to_555(BYTE red, BYTE green, BYTE blue)
  2008. {
  2009. WORD result = 0;
  2011. result = (((WORD)red>>3)<<10)|(((WORD)green>>3)<<5)|((WORD)blue>>3);
  2013. return result;
  2014. }
  2017. // 将指定的555格式的颜色转换成RGB颜色分量
  2018. void _cnv_555_to_rgb(WORD col, PBYTE red, PBYTE green, PBYTE blue)
  2019. {
  2020. // 在555转换到RGB时，将像素的亮度调到最大
  2021. *red = (BYTE)((col>>7)&0xf8);
  2022. *green = (BYTE)((col>>2)&0xf8);
  2023. *blue = (BYTE)(col<<3);
  2024. }
  2027. // 将指定的RGB颜色分量转换成565格式（WORD型值返回）
  2028. WORD _cnv_rgb_to_565(BYTE red, BYTE green, BYTE blue)
  2029. {
  2030. WORD result = 0;
  2032. result = (((WORD)red>>3)<<11)|(((WORD)green>>2)<<5)|((WORD)blue>>3);
  2034. return result;
  2035. }
  2038. // 将指定的565格式的颜色转换成RGB颜色分量
  2039. void _cnv_565_to_rgb(WORD col, PBYTE red, PBYTE green, PBYTE blue)
  2040. {
  2041. // 在565转换到RGB时，将像素的亮度调到最大
  2042. *red = (BYTE)((col>>8)&0xf8);
  2043. *green = (BYTE)((col>>3)&0xfc);
  2044. *blue = (BYTE)(col<<3);
  2045. }
  2048. // 将指定的RGB颜色分量转换成888格式（DWORD型值返回）
  2049. DWORD _cnv_rgb_to_888(BYTE red, BYTE green, BYTE blue)
  2050. {
  2051. DWORD result = 0;
  2053. result = ((DWORD)red<<16)|((DWORD)green<<8)|(DWORD)blue;
  2055. return result;
  2056. }
  2058. // 将指定的555颜色分量转换成565格式
  2059. WORD _cnv_555_to_565(WORD w555)
  2060. {
  2063. return (WORD)(((w555&0x7FE0)<<1)|(w555&0x1F));
  2066. }