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

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

图形图象

开发平台：

Visual C++

PcxLoad.cpp：源码内容
  1. #include "stdafx.h"
  2. #include "PcxDeclare.h"
  3. #include "PcxModule.h"
  4. #include "FuncFromYz.h"
  5. #include "PcxError.h"
  6. #include "PcxPalette.h"
  7. #define PCX_BUF_MAX 124
  9. #define DIBSCANLINE_WIDTHBYTES(bits)    (((bits)+31)/32*4)
  10. EXERESULT api_Isee_Check_Command_Load(INFOSTR *pInfo)
  11. {
  12. // 检验入口参数是否符合接口定义
  13. ASSERT(pInfo->result == ER_EMPTY);
  14. ASSERT(::strlen(pInfo->filename));
  15. // 此时，该文件必需是一个已存在的、有效的PCX文件，并且数据包中
  16. // 含有该文件的信息（imginfo结构中）
  17. ASSERT(pInfo->state == PKST_PASSINFO);
  18. ASSERT(pInfo->imginfo.imgformat == IMF_PCX);
  19. ASSERT(pInfo->pImgInfo == NULL);
  20. // 必需设置标准图像格式信息
  21. ASSERT(pInfo->sDIBInfo.bmi.biSize == sizeof(BITMAPINFOHEADER));
  22. ASSERT(pInfo->pLineAddr != NULL);
  23. ASSERT(pInfo->_pbdata != NULL);
  25. return ER_SUCCESS;
  26. };
  27. EXERESULT Isee_Api_Access_Progress(INFOSTR *pInfo, int MaxPreg, int CurrentPreg)
  28. {
  29. if (pInfo->fpProgress)
  30. {
  31. if ((*pInfo->fpProgress)(MaxPreg, CurrentPreg))
  32. { // 如果进度函数返回1，则说明用户想中断操作，返回。
  33. pInfo->result = ER_USERBREAK;
  34. return ER_USERBREAK;
  35. }
  36. }
  37. return ER_SUCCESS;
  38. };
  39. void Pcx_Access_Progress(INFOSTR *pInfo, int MaxPreg = 0, int CurrentPreg = 0)
  40. {
  41. if (pInfo->fpProgress)
  42. {
  43. if ((*pInfo->fpProgress)(100, 6))
  44. { // 如果进度函数返回1，则说明用户想中断操作，返回(throw)。
  45. pInfo->result = ER_USERBREAK;//仅此函数更改返回值
  46. ApiThrowMyExce(ENO_USERBREAK);//throw 跳到 catch
  47. }
  48. }
  49. }
  51. BOOL Success(int tag_param)
  52. {
  53. return (tag_param == ER_SUCCESS);
  54. };
  56. EXERESULT Pcx_Load_sub_1(INFOSTR * pInfo, LPCSTR lpData, int iDataSize);
  57. EXERESULT Pcx_Load_sub_4(INFOSTR * pInfo, LPCSTR lpData, int iDataSize);
  58. EXERESULT Pcx_Load_sub_8(INFOSTR * pInfo, LPCSTR lpData, int iDataSize);
  59. EXERESULT Pcx_Load_sub_24(INFOSTR * pInfo, LPCSTR lpData, int iDataSize);
  61. void PcxFitPinfo(INFOSTR * pInfo)
  62. {
  63. HGLOBAL p = (HGLOBAL)pInfo->pImgInfo;
  64. // ::GlobalUnlock(p);
  65. if(p == NULL)return;
  66. ::GlobalFree(p);
  67. pInfo->pImgInfo = NULL;
  68. }
  70. void Pcx_Load_From_File(INFOSTR * pInfo)
  71. {
  72. EXERESULT rt = ER_SUCCESS;//希望能顺利执行！^_^
  74. rt = api_Isee_Check_Command_Load(pInfo);
  75. if(! Success(rt))
  76. {
  77. pInfo->result = rt;
  78. return;
  79. }
  81. unsigned long bitcount = 0;
  82. ENUM_EXCE_NO no = ENO_OK;
  84. HANDLE hf = NULL;
  85. DWORD filesize = 0;
  86. HANDLE hMapping = NULL;
  87. LPSTR lpData = NULL;
  88. const char * pcStrFileName = pInfo->filename;
  90. rt = Isee_Api_Access_Progress(pInfo,100,100);//rt 已设
  92. filesize = (DWORD)pInfo->imginfo.filesize;
  93. try
  94. {
  95. hf = CreateFile(pcStrFileName,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
  96. if( hf == INVALID_HANDLE_VALUE)
  97. {
  98. rt = ER_FILERWERR;
  99. ApiThrowMyExce(ENO_CREATE_FILE_EX);
  100. }
  101. hMapping = CreateFileMapping(hf,NULL,PAGE_READONLY,0,filesize,NULL);
  102. if(hMapping == NULL)
  103. {
  104. rt = ER_MEMORYERR;
  105. ApiThrowMyExce(ENO_CREATE_MAP_EX);
  106. }
  108. lpData = (LPSTR)MapViewOfFile(hMapping,FILE_MAP_READ,0,0,0);
  109. if(lpData == NULL)
  110. {
  111. rt = ER_MEMORYERR;
  112. ApiThrowMyExce(ENO_MAP_VIEW_EX);
  113. }
  115. PcxDoWithPalette(pInfo, lpData,filesize);
  117. bitcount = pInfo->imginfo.bitcount;
  118. switch(bitcount)
  119. {
  120. case 1:
  121. rt = Pcx_Load_sub_1(pInfo, lpData, filesize);
  122. break;
  123. case 4:
  124. rt = Pcx_Load_sub_4(pInfo, lpData, filesize);
  125. break;
  126. case 8:
  127. rt = Pcx_Load_sub_8(pInfo, lpData, filesize);
  128. break;
  129. case 24:
  130. rt = Pcx_Load_sub_24(pInfo, lpData, filesize);
  131. break;
  132. }
  133. }
  134. catch(CMyException myExce)
  135. {
  136. no = myExce.GetNo();
  137. CString str;
  139. }
  140. switch(no)
  141. {
  142. default:
  143. case ENO_OK:
  144. case ENO_USERBREAK:
  145. //rt 已设
  146. rt = pInfo->result;
  148. UnmapViewOfFile(lpData);
  149. case ENO_MAP_VIEW_EX:
  150. CloseHandle(hMapping);
  151. case ENO_CREATE_MAP_EX:
  152. CloseHandle(hf);
  153. case ENO_CREATE_FILE_EX:
  154. rt = ER_FILERWERR;
  155. }
  156. Isee_Api_Access_Progress(pInfo,100,100);//rt 已设
  157. //***************************
  158. PcxFitPinfo(pInfo);
  159. pInfo->state = PKST_INFOANDBITS;
  160. pInfo->modify = 0;
  161. pInfo->result = ER_SUCCESS;
  163. //不允许中断
  164. return;
  165. };
  166. EXERESULT Pcx_Load_sub_4(INFOSTR * pInfo, LPCSTR lpData, int iDataSize)
  167. {
  169. const PCXFILEHEADER *const pcxFileHead=(const PCXFILEHEADER *) lpData;//文件头
  170. LPCSTR const pImage = lpData + sizeof(PCXFILEHEADER);//图像数据、读取起点
  171. const struct PcxPalette * const lpPalette = (struct PcxPalette * )pcxFileHead->byPalette;//调色板
  173. //from yz
  174. DWORD imgheight = pInfo->imginfo.height; // 图像的高度
  175. DWORD imgwidth  = pInfo->imginfo.width; // 图像的宽度
  176. DWORD dwDestFormat = _get_desformat(pInfo);//目标格式
  178. DWORD dwPcxOneScanLineSize  = pcxFileHead->wLineBytes;// 每一扫描行的宽度(in byte)
  179. DWORD dwPcxLineSizeCount = pcxFileHead->wLineBytes * pcxFileHead->byPlanes;
  181. DWORD dwImageHeightCount, dwImageWidthCount;//用于计数
  182. //
  184. char * const pScanLineBuf = (char *)new char[dwPcxLineSizeCount + 16];//16 for 安全
  185. //解压缓冲区
  186. if(pScanLineBuf == NULL)
  187. ApiMyThrowMem();
  190. WORD * pLineDest = NULL;//目标行首地址、
  191. WORD * pLineSource = NULL;//源行首地址、
  192. pLineSource = (WORD *)pScanLineBuf;//源....
  193. // WORD * pPixDest = NULL;//目标地址、(目标地址分别定义)
  195. BYTE ch1,ch2;
  196. char * pScan = NULL;////解压指针
  197. DWORD ScanLinePoint = 0;//解压计数
  199. // 以各种格式的调色板数据
  200. //..放在循环外、以空间换取时间
  201. WORD descol555[16];
  202. WORD descol565[16];
  203. DWORD descol888[16];
  204. WORD * pDesPixAddr555 = NULL;
  205. WORD * pDesPixAddr565 = NULL;
  206. BYTE * pDesPixAddr24 = NULL;
  207. DWORD * pDesPixAddr888 = NULL;
  208. int i;
  209. switch(dwDestFormat) // 标准图像格式（目标格式）
  210. {
  211. case DF_16_555:
  212. {
  213. for (i=0;i<16;i++) // 初始化色素颜色数据
  214. descol555[i] = _cnv_rgb_to_555(lpPalette[i].byRed, lpPalette[i].byGreen, lpPalette[i].byBlue);
  215. }
  216. break;
  217. case DF_16_565:
  218. {
  219. for (i=0;i<16;i++) // 初始化色素颜色数据
  220. descol565[i] = _cnv_rgb_to_565(lpPalette[i].byRed, lpPalette[i].byGreen, lpPalette[i].byBlue);
  221. }
  222. break;
  223. case DF_32:
  224. {
  225. for (i=0;i<16;i++) // 初始化色素颜色数据
  226. descol888[i] = _cnv_rgb_to_888(lpPalette[i].byRed, lpPalette[i].byGreen, lpPalette[i].byBlue);
  227. }
  228. break;
  229. default:
  230. break;
  231. }
  233. // int i, j;//, isou;
  234. // DWORD dwPCXLineSizeCount;
  235. //char * pSrc = ;
  236. char k;//解压计数
  238. // char *lpPlane0,*lpPlane1,*lpPlane2,*lpPlane3;//解码指针
  239. BYTE byPlane0,byPlane1,byPlane2,byPlane3;//码值
  240. // BYTE byIndex1,byIndex2,byIndex3,byIndex4;//解码值
  241. // BYTE byIndex5,byIndex6,byIndex7,byIndex8;//解码值
  243. LPCSTR pSrc = pImage;//读取起点//类似流（？）:-)
  244. for(dwImageHeightCount=0;dwImageHeightCount<imgheight;dwImageHeightCount++)//Pcx 总是正向
  245. {
  246. pScan = (char *)(pScanLineBuf);
  247. ScanLinePoint = 0;
  248. //while(ScanLinePoint <dwPCXScanLineSize&&!feof(f1))//base 0;Index
  249. while(ScanLinePoint <dwPcxLineSizeCount)//base 0;Index
  250. {
  251. if((pSrc - lpData)>=iDataSize)break;
  252. ch1=(*pSrc ++)&0xFF;//fgetc() return int;
  253. if((ch1&0xc0)==0xC0)
  254. {
  255. k = ch1&0x3F;
  256. ch2 = (*pSrc ++)&0xFF;
  257. while(k--)//&&ScanLinePoint<dwPCXScanLineSize)
  258. {
  259. pScan[ScanLinePoint++] = ch2;//
  260. }
  261. }
  262. else
  263. {
  264. pScan[ScanLinePoint++] = ch1;
  265. }
  266. }//while (pcxLineWidth)//解压一行
  269. pLineDest = (WORD*)pInfo->pLineAddr[dwImageHeightCount];//当前目标 (行)
  270. //源在pLineBuf
  271. pLineSource = (WORD *)pScanLineBuf;//源....
  272. //源地址总是不变
  274. //目标 都在此初始化
  275. pDesPixAddr555 = (WORD * )pLineDest;
  276. pDesPixAddr565 = (WORD * )pLineDest;
  277. pDesPixAddr24 = (BYTE * )pLineDest;
  279. pDesPixAddr888 = (DWORD * )pLineDest;
  280. dwImageWidthCount = 0;
  282. for(ScanLinePoint=0;ScanLinePoint<dwPcxOneScanLineSize;ScanLinePoint++)//解码一行
  283. {
  284. //****************************************//read 1 byte;
  285. byPlane0 = *((char *)pScanLineBuf+dwPcxOneScanLineSize*0+ScanLinePoint);
  286. byPlane1 = *((char *)pScanLineBuf+dwPcxOneScanLineSize*1+ScanLinePoint);
  287. byPlane2 = *((char *)pScanLineBuf+dwPcxOneScanLineSize*2+ScanLinePoint);
  288. byPlane3 = *((char *)pScanLineBuf+dwPcxOneScanLineSize*3+ScanLinePoint);
  289. //****************************************
  290. //point 1-2 in 1st byte
  291. int i;
  292. BYTE byFlag = 1; //掩码
  293. BYTE byIndex;
  294. for(i = 7; i>=0;i--)//(高位在前)
  295. {
  296. byFlag = 1<<i;
  298. byIndex=0x00;
  299. byIndex |=((byPlane3 & byFlag)? 0x08:byIndex);
  300. byIndex |=((byPlane2 & byFlag)? 0x04:byIndex);
  301. byIndex |=((byPlane1 & byFlag)? 0x02:byIndex);
  302. byIndex |=((byPlane0 & byFlag)? 0x01:byIndex);
  303. {
  304. }
  306. switch(dwDestFormat) // 标准图像格式（目标格式）
  307. {
  308. case DF_16_555:
  309. {
  310. if(dwImageWidthCount < imgwidth)
  311. {
  312. *pDesPixAddr555++ = descol555[byIndex];
  313. dwImageWidthCount ++;
  314. }
  315. break;
  316. }
  317. case DF_16_565:
  318. {
  319. if(dwImageWidthCount < imgwidth)
  320. {
  321. *pDesPixAddr565++ = descol565[byIndex];
  322. dwImageWidthCount ++;
  323. }
  325. break;
  326. }
  328. case DF_24:
  329. {
  330. if(dwImageWidthCount < imgwidth)
  331. {
  332. *pDesPixAddr24++ = lpPalette[byIndex].byBlue;
  333. *pDesPixAddr24++ = lpPalette[byIndex].byGreen;
  334. *pDesPixAddr24++ = lpPalette[byIndex].byRed;
  335. }
  336. break;
  337. }
  338. case DF_32:
  339. {
  340. if(dwImageWidthCount < imgwidth)
  341. {
  342. *pDesPixAddr888++ = descol888[byIndex];
  343. dwImageWidthCount ++;
  344. }
  345. break;
  346. }
  347. case DF_NULL:
  348. default:
  349. ASSERT(FALSE);
  350. pInfo->result = ER_ILLCOMM;
  351. return ER_ILLCOMM;
  352. break;
  353. }//switch(dwDestFormat)
  354. }//for 每8个像素
  355. }//for dwScanLineSize;
  356. }//for imageheight
  357. delete pScanLineBuf;
  358. return ER_SUCCESS;
  359. };
  360. EXERESULT Pcx_Load_sub_8(INFOSTR * pInfo, LPCSTR lpData, int iDataSize)
  361. {
  363. const PCXFILEHEADER *const pcxFileHead=(const PCXFILEHEADER *) lpData;//文件头
  364. LPCSTR const pImage = lpData + sizeof(PCXFILEHEADER);//图像数据、读取起点
  365. const struct PcxPalette * lpPalette = NULL;//调色板
  366. DWORD tempPaletteCount;
  367. GetPcxPalette((struct PcxImgInfo *)pInfo->pImgInfo, (void ** )&lpPalette, &tempPaletteCount);
  368. ASSERT(lpPalette != NULL);
  369. ASSERT(tempPaletteCount == 256);
  371. //from yz
  372. DWORD imgheight = pInfo->imginfo.height; // 图像的高度
  373. DWORD imgwidth  = pInfo->imginfo.width; // 图像的宽度
  374. DWORD dwDestFormat = _get_desformat(pInfo);//目标格式
  376. DWORD dwPcxOneScanLineSize  = pcxFileHead->wLineBytes;// 每一扫描行的宽度(in byte)
  377. DWORD dwPcxLineSizeCount = pcxFileHead->wLineBytes * pcxFileHead->byPlanes;
  379. DWORD dwImageHeightCount, dwImageWidthCount;//用于计数
  380. //
  382. char * const pScanLineBuf = (char *)new char[dwPcxLineSizeCount + 16];//16 for 安全
  383. //解压缓冲区
  384. if(pScanLineBuf == NULL)
  385. ApiMyThrowMem();
  388. WORD * pLineDest = NULL;//目标行首地址、
  389. BYTE * pLineSource = NULL;//源行首地址、
  390. pLineSource = (BYTE *)pScanLineBuf;//源....
  391. // WORD * pPixDest = NULL;//目标地址、(目标地址 依格式分别定义)
  393. BYTE ch1,ch2;
  394. char * pScan = NULL;////解压指针
  395. DWORD ScanLinePoint = 0;//解压计数
  397. // 以各种格式的调色板数据
  398. //..放在循环外、以空间换取时间
  399. //WORD descol555[256];
  400. //WORD descol565[256];
  401. //DWORD descol888[256];
  402. //<节约一下吧 ^_^ >
  404. WORD * descol555 = NULL;
  405. WORD * descol565 = NULL;
  406. DWORD * descol888 = NULL;
  408. WORD * pDesPixAddr555 = NULL;
  409. WORD * pDesPixAddr565 = NULL;
  410. BYTE * pDesPixAddr24 = NULL;
  411. DWORD * pDesPixAddr888 = NULL;
  412. int i;
  413. switch(dwDestFormat) // 标准图像格式（目标格式）
  414. {
  415. case DF_16_555:
  416. {
  417. if(descol555 == NULL)
  418. ApiMyThrowMem();
  419. descol555 = new WORD[256];
  420. for (i=0;i<256;i++) // 初始化色素颜色数据
  421. descol555[i] = _cnv_rgb_to_555(lpPalette[i].byRed, lpPalette[i].byGreen, lpPalette[i].byBlue);
  422. }
  423. break;
  424. case DF_16_565:
  425. {
  426. descol565 = new WORD[256];
  427. if(descol565 == NULL)
  428. ApiMyThrowMem();
  429. for (i=0;i<256;i++) // 初始化色素颜色数据
  430. descol565[i] = _cnv_rgb_to_565(lpPalette[i].byRed, lpPalette[i].byGreen, lpPalette[i].byBlue);
  431. }
  432. break;
  433. case DF_32:
  434. {
  435. descol888 = new DWORD[256];
  436. if(descol888 == NULL)
  437. ApiMyThrowMem();
  438. for (i=0;i<256;i++) // 初始化色素颜色数据
  439. descol888[i] = _cnv_rgb_to_888(lpPalette[i].byRed, lpPalette[i].byGreen, lpPalette[i].byBlue);
  440. }
  441. break;
  442. default:
  443. break;
  444. }
  446. char k;//解压计数
  448. LPCSTR pSrc = pImage;//读取起点//类似流（？）:-)
  449. for(dwImageHeightCount=0;dwImageHeightCount<imgheight; dwImageHeightCount++)//Pcx 总是正向
  450. {
  451. pScan = (char *)(pScanLineBuf);
  452. ScanLinePoint = 0;
  453. //while(ScanLinePoint <dwPCXScanLineSize&&!feof(f1))//base 0;Index
  454. while(ScanLinePoint <dwPcxLineSizeCount)//base 0;Index
  455. {
  456. if((pSrc - lpData)>=iDataSize)break;
  457. ch1=(*pSrc ++)&0xFF;//fgetc() return int;
  458. if((ch1&0xc0)==0xC0)
  459. {
  460. k = ch1&0x3F;
  461. ch2 = (*pSrc ++)&0xFF;
  462. while(k--)//&&ScanLinePoint<dwPCXScanLineSize)
  463. {
  464. pScan[ScanLinePoint++] = ch2;//
  465. }
  466. }
  467. else
  468. {
  469. pScan[ScanLinePoint++] = ch1;
  470. }
  471. }//while (pcxLineWidth)//解压一行
  474. pLineDest = (WORD*)pInfo->pLineAddr[dwImageHeightCount];//当前目标 (行)
  475. //源在pLineBuf
  476. pLineSource = (BYTE *)pScanLineBuf;//源....
  477. //源地址总是不变
  479. //目标 都在此初始化
  480. pDesPixAddr555 = (WORD * )pLineDest;
  481. pDesPixAddr565 = (WORD * )pLineDest;
  482. pDesPixAddr24 = (BYTE * )pLineDest;
  483. pDesPixAddr888 = (DWORD * )pLineDest;
  485. dwImageWidthCount = 0;
  486. BYTE byIndex = 0;
  487. for(dwImageWidthCount = 0;dwImageWidthCount<imgwidth;dwImageWidthCount++)//解码一行
  488. {
  489. //****************************************//read 1 byte;
  490. byIndex = *((BYTE *)pLineSource + dwImageWidthCount);
  492. switch(dwDestFormat) // 标准图像格式（目标格式）
  493. {
  494. case DF_16_555:
  495. {
  496. if(dwImageWidthCount < imgwidth)
  497. {
  498. *pDesPixAddr555++ = descol555[byIndex];
  499. }
  500. break;
  501. }
  502. case DF_16_565:
  503. {
  504. if(dwImageWidthCount < imgwidth)
  505. {
  506. *pDesPixAddr565++ = descol565[byIndex];
  507. }
  508. break;
  509. }
  511. case DF_24:
  512. {
  513. if(dwImageWidthCount < imgwidth)
  514. {
  515. *pDesPixAddr24++ = lpPalette[byIndex].byBlue;
  516. *pDesPixAddr24++ = lpPalette[byIndex].byGreen;
  517. *pDesPixAddr24++ = lpPalette[byIndex].byRed;
  518. }
  519. break;
  520. }
  521. case DF_32:
  522. {
  523. if(dwImageWidthCount < imgwidth)
  524. {
  525. *pDesPixAddr888 = descol888[byIndex];
  526. pDesPixAddr888 ++;
  527. }
  528. break;
  529. }
  530. case DF_NULL:
  531. default:
  532. ASSERT(FALSE);
  533. pInfo->result = ER_ILLCOMM;
  534. return ER_ILLCOMM;
  535. break;
  536. }//switch(dwDestFormat)
  537. }//for dwScanLineSize;
  538. }//for imageheight
  539. delete pScanLineBuf;
  540. switch(dwDestFormat) // 标准图像格式（目标格式）
  541. {
  542. case DF_16_555:
  543. {
  544. if(descol555 != NULL)
  545. delete descol555;
  546. }
  547. break;
  548. case DF_16_565:
  549. {
  550. if(descol565 != NULL)
  551. delete descol565;
  552. }
  553. break;
  554. case DF_32:
  555. {
  556. if(descol888 != NULL)
  557. delete descol888;
  558. }
  559. break;
  560. default:
  561. break;
  562. }
  563. return ER_SUCCESS;
  564. };
  565. EXERESULT Pcx_Load_sub_24(INFOSTR * pInfo, LPCSTR lpData, int iDataSize)
  566. {
  567. const PCXFILEHEADER *const pcxFileHead=(const PCXFILEHEADER *) lpData;//文件头
  568. LPCSTR const pImage = lpData + sizeof(PCXFILEHEADER);//图像数据、读取起点
  569. // const struct PcxPalette * const lpPalette = (struct PcxPalette * )pcxFileHead->byPalette;//调色板
  571. //from yz
  572. DWORD imgheight = pInfo->imginfo.height; // 图像的高度
  573. DWORD imgwidth  = pInfo->imginfo.width; // 图像的宽度
  574. DWORD dwDestFormat = _get_desformat(pInfo);//目标格式
  576. DWORD dwPcxOneScanLineSize  = pcxFileHead->wLineBytes;// 每一扫描行的宽度(in byte)
  577. DWORD dwPcxLineSizeCount = pcxFileHead->wLineBytes * pcxFileHead->byPlanes;
  579. DWORD dwImageHeightCount, dwImageWidthCount;//用于计数
  580. //
  582. char * const pScanLineBuf = (char *)new char[dwPcxLineSizeCount + 16];//16 for 安全
  583. //解压缓冲区
  584. if(pScanLineBuf == NULL)
  585. ApiMyThrowMem();
  588. WORD * pLineDest = NULL;//目标行首地址、
  589. WORD * pLineSource = NULL;//源行首地址、
  590. pLineSource = (WORD *)pScanLineBuf;//源....
  591. // WORD * pPixDest = NULL;//目标地址、(目标地址分别定义)
  593. BYTE ch1,ch2;
  594. char * pScan = NULL;////解压指针
  595. DWORD ScanLinePoint = 0;//解压计数
  597. WORD * pDesPixAddr555 = NULL;
  598. WORD * pDesPixAddr565 = NULL;
  599. BYTE * pDesPixAddr24 = NULL;
  600. DWORD * pDesPixAddr888 = NULL;
  601. // int i;
  603. // int i, j;//, isou;
  604. // DWORD dwPCXLineSizeCount;
  605. //char * pSrc = ;
  606. char k;//解压计数
  608. // char *lpPlane0,*lpPlane1,*lpPlane2,*lpPlane3;//解码指针
  609. BYTE byPlane0,byPlane1,byPlane2;//,byPlane3;//码值
  610. // BYTE byIndex1,byIndex2,byIndex3,byIndex4;//解码值
  611. // BYTE byIndex5,byIndex6,byIndex7,byIndex8;//解码值
  613. LPCSTR pSrc = pImage;//读取起点//类似流（？）:-)
  614. for(dwImageHeightCount=0;dwImageHeightCount<imgheight;dwImageHeightCount++)//Pcx 总是正向
  615. {
  616. pScan = (char *)(pScanLineBuf);
  617. ScanLinePoint = 0;
  618. //while(ScanLinePoint <dwPCXScanLineSize&&!feof(f1))//base 0;Index
  619. while(ScanLinePoint <dwPcxLineSizeCount)//base 0;Index
  620. {
  621. if((pSrc - lpData)>=iDataSize)break;
  622. ch1=(*pSrc ++)&0xFF;//fgetc() return int;
  623. if((ch1&0xc0)==0xC0)
  624. {
  625. k = ch1&0x3F;
  626. ch2 = (*pSrc ++)&0xFF;
  627. while(k--)//&&ScanLinePoint<dwPCXScanLineSize)
  628. {
  629. pScan[ScanLinePoint++] = ch2;//
  630. }
  631. }
  632. else
  633. {
  634. pScan[ScanLinePoint++] = ch1;
  635. }
  636. }//while (pcxLineWidth)//解压一行
  639. pLineDest = (WORD*)pInfo->pLineAddr[dwImageHeightCount];//当前目标 (行)
  640. //源在pLineBuf
  641. pLineSource = (WORD *)pScanLineBuf;//源....
  642. //源地址总是不变
  644. //目标 都在此初始化
  645. pDesPixAddr555 = (WORD * )pLineDest;
  646. pDesPixAddr565 = (WORD * )pLineDest;
  647. pDesPixAddr24 = (BYTE * )pLineDest;
  649. pDesPixAddr888 = (DWORD * )pLineDest;
  650. dwImageWidthCount = 0;
  652. for(ScanLinePoint=0;ScanLinePoint<dwPcxOneScanLineSize;ScanLinePoint++)//解码一行
  653. {
  654. //****************************************//read 1 byte;
  655. byPlane0 = *((char *)pScanLineBuf+dwPcxOneScanLineSize*0+ScanLinePoint);
  656. byPlane1 = *((char *)pScanLineBuf+dwPcxOneScanLineSize*1+ScanLinePoint);
  657. byPlane2 = *((char *)pScanLineBuf+dwPcxOneScanLineSize*2+ScanLinePoint);
  659. switch(dwDestFormat) // 标准图像格式（目标格式）
  660. {
  661. case DF_16_555:
  662. {
  663. if(dwImageWidthCount < imgwidth)
  664. {
  665. *pDesPixAddr555++ = _cnv_rgb_to_555(byPlane0, byPlane1, byPlane2);
  666. dwImageWidthCount ++;
  667. }
  668. break;
  669. }
  670. case DF_16_565:
  671. {
  672. if(dwImageWidthCount < imgwidth)
  673. {
  674. *pDesPixAddr565++ =  _cnv_rgb_to_565(byPlane0, byPlane1, byPlane2);
  675. dwImageWidthCount ++;
  676. }
  678. break;
  679. }
  681. case DF_24:
  682. {
  683. if(dwImageWidthCount < imgwidth)
  684. {
  685. *pDesPixAddr24++ = byPlane0;
  686. *pDesPixAddr24++ = byPlane1;
  687. *pDesPixAddr24++ = byPlane2;
  688. }
  689. break;
  690. }
  691. case DF_32:
  692. {
  693. if(dwImageWidthCount < imgwidth)
  694. {
  695. *pDesPixAddr888++ =  _cnv_rgb_to_888(byPlane0, byPlane1, byPlane2);
  696. dwImageWidthCount ++;
  697. }
  698. break;
  699. }
  700. case DF_NULL:
  701. default:
  702. ASSERT(FALSE);
  703. pInfo->result = ER_ILLCOMM;
  704. return ER_ILLCOMM;
  705. break;
  706. }//switch(dwDestFormat)
  707. }//for dwScanLineSize;
  708. }//for imageheight
  709. delete pScanLineBuf;
  710. return ER_SUCCESS;
  711. };
  712. EXERESULT Pcx_Load_sub_1(INFOSTR * pInfo, LPCSTR lpData, int iDataSize)
  713. {
  715. const PCXFILEHEADER *const pcxFileHead=(const PCXFILEHEADER *) lpData;
  716. LPCSTR const pImage = lpData + sizeof(PCXFILEHEADER);//图像数据、读取起点
  717. struct PcxPalette * lpPalette = (struct PcxPalette * )pcxFileHead->byPalette;
  720. //?*** from yz
  721. DWORD imgheight = pInfo->imginfo.height; // 图像的高度
  722. DWORD imgwidth  = pInfo->imginfo.width; // 图像的宽度
  723. DWORD pcxLineWidth = pcxFileHead->wLineBytes * pcxFileHead->byPlanes;
  724. DWORD scansize  = pInfo->imginfo.linesize;// 每一扫描行的宽度(in byte)
  725. DWORD heigCount, widthCount;
  726. DWORD dwDestFormat = _get_desformat(pInfo);
  728. PBYTE pCurPixAddr;
  729. try
  730. {
  731. BYTE pix;
  732. BYTE ch1,ch2;
  733. char *pScanLineBuf = (char *)new char[pcxLineWidth + 16];//16 for 安全
  734. if(pScanLineBuf == NULL)
  735. ApiMyThrowMem();
  736. char * pScan = NULL;
  737. WORD * pLineDest = NULL;
  739. DWORD ScanLinePoint = 0;
  740. int i, j;//, isou;
  741. // DWORD dwPCXLineSizeCount;
  742. //char * pSrc = ;
  743. char k;
  745. // char *lpPlane0,*lpPlane1,*lpPlane2,*lpPlane3;
  746. // BYTE byPlane0,byPlane1,byPlane2,byPlane3;
  747. // char * pReceiveLine; //= new char[dwBmpLineSize];
  749. LPCSTR pSrc = pImage;//图像数据、读取起点
  751. for(heigCount=0;heigCount<imgheight;heigCount++)//Pcx 总是正向
  752. {
  753. pScan = (char *)(pScanLineBuf);
  754. ScanLinePoint = 0;
  755. //while(ScanLinePoint <dwPCXScanLineSize&&!feof(f1))//base 0;Index
  756. while(ScanLinePoint <pcxLineWidth)//base 0;Index
  757. {
  758. if((pSrc - lpData)>=iDataSize)break;
  759. ch1=(*pSrc ++)&0xFF;//fgetc() return int;
  760. if((ch1&0xc0)==0xC0)
  761. {
  762. k = ch1&0x3F;
  763. ch2 = (*pSrc ++)&0xFF;
  764. while(k--)//&&ScanLinePoint<dwPCXScanLineSize)
  765. {
  766. pScan[ScanLinePoint++] = ch2;//
  767. }
  768. }
  769. else
  770. {
  771. pScan[ScanLinePoint++] = ch1;
  772. }
  773. }//line
  775. pLineDest = (WORD*)pInfo->pLineAddr[heigCount];//目标
  776. //源在pLineBuf
  777. pCurPixAddr  = (PBYTE)(pScanLineBuf); // 源图像当前行的第一个像素地址
  779. switch(dwDestFormat)//from yz
  780. {
  781. case DF_16_555:
  782. {
  783. // 以555位格式的调色板数据
  784. WORD descol555_0 = 0;
  785. WORD descol555_1 = 0;
  787. descol555_0 = _cnv_rgb_to_555(lpPalette[0].byRed, lpPalette[0].byGreen, lpPalette[0].byBlue);
  788. descol555_1 = _cnv_rgb_to_555(lpPalette[1].byRed, lpPalette[1].byGreen, lpPalette[1].byBlue);
  789. WORD *pDesPixAddr555;
  791. // 正向位图（top-down）
  792. {
  793. {
  794. //pCurPixAddr  = pLineBuf; // 源图像当前行的第一个像素地址
  795. pDesPixAddr555  = (WORD *)pLineDest;// 目标缓冲区当前行第一个像素的地址
  796. for (widthCount=0;widthCount<imgwidth;widthCount+=8)
  797. {
  798. pix = *pCurPixAddr++;
  800. if ((imgwidth-widthCount)<8) // 结尾判断
  801. j = imgwidth-widthCount;
  802. else
  803. j = 8;
  805. for (i=0;i<j;i++)
  806. {
  807. if (((BYTE)(0x80>>i))&pix) // 此位被设置
  808. {
  809. *pDesPixAddr555++ = descol555_1;
  810. }
  811. else
  812. {
  813. *pDesPixAddr555++ = descol555_0;
  814. }
  815. }
  816. }
  817. }
  818. }
  819. }
  820. break;
  821. case DF_16_565:
  822. {
  823. // 以565位格式的调色板数据
  824. WORD descol565_0 = 0;
  825. WORD descol565_1 = 0;
  827. descol565_0 = _cnv_rgb_to_565(lpPalette[0].byRed, lpPalette[0].byGreen, lpPalette[0].byBlue);
  828. descol565_1 = _cnv_rgb_to_565(lpPalette[1].byRed, lpPalette[1].byGreen, lpPalette[1].byBlue);
  830. WORD *pDesPixAddr565;
  832. // 正向位图（top-down）
  833. {
  834. {
  835. pDesPixAddr565  = (WORD *)pLineDest;// 目标缓冲区当前行第一个像素的地址
  836. for (widthCount=0;widthCount<imgwidth;widthCount+=8)
  837. {
  838. pix = *pCurPixAddr++;
  840. if ((imgwidth-widthCount)<8) // 结尾判断
  841. j = imgwidth-widthCount;
  842. else
  843. j = 8;
  845. for (i=0;i<j;i++)
  846. {
  847. if (((BYTE)(0x80>>i))&pix) // 此位被设置
  848. {
  849. *pDesPixAddr565++ = descol565_1;
  850. }
  851. else
  852. {
  853. *pDesPixAddr565++ = descol565_0;
  854. }
  855. }
  856. }
  857. }
  858. }
  859. }
  860. break;
  861. case DF_24:
  862. {
  863. // 24位格式的调色板数据
  864. BYTE red0, red1, green0, green1, blue0, blue1;
  866. red0 = lpPalette[0].byRed;
  867. green0 = lpPalette[0].byGreen;
  868. blue0 = lpPalette[0].byBlue;
  869. red1 = lpPalette[1].byRed;
  870. green1 = lpPalette[1].byGreen;
  871. blue1 = lpPalette[1].byBlue;
  873. PBYTE pDesPixAddr24;
  875. // 正向位图（top-down）
  876. {
  877. {
  878. pDesPixAddr24  = (PBYTE)pLineDest;// 目标缓冲区当前行第一个像素的地址
  879. for (widthCount=0;widthCount<imgwidth;widthCount+=8)
  880. {
  881. pix = *pCurPixAddr++;
  883. if ((imgwidth-widthCount)<8) // 结尾判断
  884. j = imgwidth-widthCount;
  885. else
  886. j = 8;
  888. for (i=0;i<j;i++)
  889. {
  890. if (((BYTE)(0x80>>i))&pix) // 此位被设置
  891. {
  892. *pDesPixAddr24++ = blue1;
  893. *pDesPixAddr24++ = green1;
  894. *pDesPixAddr24++ = red1;
  895. }
  896. else
  897. {
  898. *pDesPixAddr24++ = blue0;
  899. *pDesPixAddr24++ = green0;
  900. *pDesPixAddr24++ = red0;
  901. }
  902. }
  903. }
  904. }
  905. }
  906. }
  907. break;
  908. case DF_32:
  909. {
  910. // 以888位格式的调色板数据
  911. DWORD descol888_0 = 0;
  912. DWORD descol888_1 = 0;
  914. descol888_0 = _cnv_rgb_to_888(lpPalette[0].byRed, lpPalette[0].byGreen, lpPalette[0].byBlue);
  915. descol888_1 = _cnv_rgb_to_888(lpPalette[1].byRed, lpPalette[1].byGreen, lpPalette[1].byBlue);
  917. DWORD *pDesPixAddr888;
  919. // 正向位图（top-down）
  920. {
  921. ///for (heigCount=0;heigCount<imgheight;heigCount++)
  922. {
  923. //pCurPixAddr  = (PBYTE)(lpSou+heigCount*scansize); // 源图像当前行的第一个像素地址
  924. pDesPixAddr888  = (DWORD *)pLineDest;// 目标缓冲区当前行第一个像素的地址
  925. for (widthCount=0;widthCount<imgwidth;widthCount+=8)
  926. {
  927. pix = *pCurPixAddr++;
  929. if ((imgwidth-widthCount)<8) // 结尾判断
  930. j = imgwidth-widthCount;
  931. else
  932. j = 8;
  934. for (i=0;i<j;i++)
  935. {
  936. if (((BYTE)(0x80>>i))&pix) // 此位被设置
  937. {
  938. *pDesPixAddr888++ = descol888_1;
  939. }
  940. else
  941. {
  942. *pDesPixAddr888++ = descol888_0;
  943. }
  944. }
  945. }
  946. }
  947. }
  948. }
  949. break;
  950. case DF_NULL:
  951. default:
  952. ASSERT(FALSE);
  953. pInfo->result = ER_ILLCOMM;
  954. //return ;
  955. break;
  956. }//switch
  957. }//for height
  959. delete pScanLineBuf;
  961. }//try
  962. catch(...)
  963. {
  964. throw;
  965. }
  966. return ER_SUCCESS;
  967. };