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

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

图形图象

开发平台：

Visual C++

PsdModule.cpp：源码内容
  1. /*----------------------------------------------------------------------------------*
  2. $                                                                                    $
  3. =>  000000    000000   00000000     PSD File Format Read Program                     $
  4. =>  00   00  00        00     00     这是自由软件 ISee 图像浏览器的一部分            $
  5. =>  00   00  00        00      00     这个模块实现了 PSD 格式的读取                  $
  6. =>  000000    000000   00      00     这个模块的当前版本是 1.5                       $
  7. =>  00             00  00      00     这个模块的当前作者是 Pegasus                   $
  8. =>  00             00  00     00     这个模块的主架构来自于 YZ 的 BMP 模块           $
  9. =>  00        000000   00000000     这个模块的部分函数也来自于 YZ                    $
  10. $                                                                                    $
  11. *---------------------------------------------------------------------2000-10-27---*/
  13. //
  14. //=> 这是你二个版本，不第一个版本节省了一些内存，但程序也增加了一些，模块化少了，请见谅
  15. //
  17. // 测试日志
  18. //||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||\
  19. ////////////// 当前模块还没有实现 CMYK 和 Lab 颜色格式的真正读取
  20. ///////////// 我用于测试的所有图像都是来自于 Photoshop V5.0.2
  21. //////////// 用于测试的图像有大小 216*297 和 20*100 的 以及 Photoshop 5.0.2 自带的图像
  22. /////////// 目前支持的图像有：
  23. ////////// RGB色,8位,RLE压缩与无压缩; RGB色,16位,无压缩;
  24. ///////// 灰度,8位,RLE压缩与无压缩; 灰度,16位,无压缩;
  25. //////// 单色,1位,按位存储;
  26. /////// Duotone, 8位,RLE压缩与无压缩; // 相近读取(灰度)
  27. ////// CMYK色,8位,RLE压缩与无压缩; CMYK色,16位,无压缩; // 相近读取(丢掉黑色)
  28. ///// Lab色,8位,RLE压缩与无压缩; // 相近读取(灰度)
  29. //// Multichannel(多通道),按8位RGB来读,当图的通道数少于3时，颜色会发生大的变化
  30. /// ACDSee处理通道数少于3的图像的方法是-显示全黑色，可我让他显示变色的图
  31. // 当前我对CMYK的处理是丢去黑色，这样会使颜色发生变化，ACDSee也会但他变得少
  32. // 当前我对Lab的处理也是丢去a与b的分量，这样使图像成了灰度的图
  33. // 此程序还有多处可以优化！！！ ^_^
  34. //
  35. // eMail : Pegasusgod@163.net
  36. //
  37. // PsdModule.cpp : Defines the initialization routines for the DLL.
  40. #include "stdafx.h"
  41. #include "PsdModule.h"
  42. #include "FormYZ.h"
  44. #ifdef _DEBUG
  45. #define new DEBUG_NEW
  46. #undef THIS_FILE
  47. static char THIS_FILE[] = __FILE__;
  48. #endif
  50. static char ModuleProcessImgType[]="PSD"; // 本模块能处理的图像类型
  51. static char WriterList[]="Pegasus"; // 本模块的作者列表
  52. static char WriterMess[]="请不要写作者留言!! ^_^"; // 作者留言
  54. //
  55. // Note!
  56. //
  57. // If this DLL is dynamically linked against the MFC
  58. // DLLs, any functions exported from this DLL which
  59. // call into MFC must have the AFX_MANAGE_STATE macro
  60. // added at the very beginning of the function.
  61. //
  62. // For example:
  63. //
  64. // extern "C" BOOL PASCAL EXPORT ExportedFunction()
  65. // {
  66. // AFX_MANAGE_STATE(AfxGetStaticModuleState());
  67. // // normal function body here
  68. // }
  69. //
  70. // It is very important that this macro appear in each
  71. // function, prior to any calls into MFC.  This means that
  72. // it must appear as the first statement within the 
  73. // function, even before any object variable declarations
  74. // as their constructors may generate calls into the MFC
  75. // DLL.
  76. //
  77. // Please see MFC Technical Notes 33 and 58 for additional
  78. // details.
  79. //
  81. // 在图像读写模块中，如果想分配内存，请使用API函数GlobalAlloc()
  82. // ，如果想释放内存请使用GlobalFree()函数。不要使用诸如：new
  83. // 、malloc()等函数。这是为了使各模块之间可以异地释放内存。
  84. //
  85. //
  87. /////////////////////////////////////////////////////////////////////////////
  88. // CPsdModuleApp
  90. BEGIN_MESSAGE_MAP(CPsdModuleApp, CWinApp)
  91. //{{AFX_MSG_MAP(CPsdModuleApp)
  92. // NOTE - the ClassWizard will add and remove mapping macros here.
  93. //    DO NOT EDIT what you see in these blocks of generated code!
  94. //}}AFX_MSG_MAP
  95. END_MESSAGE_MAP()
  97. /////////////////////////////////////////////////////////////////////////////
  98. // CPsdModuleApp construction
  100. CPsdModuleApp::CPsdModuleApp()
  101. {
  102. // TODO: add construction code here,
  103. // Place all significant initialization in InitInstance
  104. }
  106. /////////////////////////////////////////////////////////////////////////////
  107. // The one and only CPsdModuleApp object
  109. CPsdModuleApp theApp;
  111. // 接口函数声明 — 第一层，唯一与外界联系的接口
  112. int WINAPI AccessPSDModule(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: // 判断指定文件是否是有效的WMF文件
  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: // 判断指定文件是否是有效的PSD文件
  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_NOTSUPPORT;
  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. // 判断指定文件是否是有效的PSD文件
  288. void _fnCMD_IS_VALID_FILE(INFOSTR *pInfo)
  289. {
  290. CFile file ;
  291. PSDFILEHEADER PsdHeader ;
  292. DWORD dwFileSize ;
  293. UINT uReadSize ;
  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. // 设初值
  304. pInfo->result = ER_SUCCESS;
  305. pInfo->annexdata.iAnnData = 0;
  307. // 先判断指定的文件是否存在
  308. if (!IsFileExist(pInfo->filename))
  309. pInfo->result = ER_COMMINFOERR;
  310. else
  311. {
  312. // 打开指定文件
  313. if (!file.Open(pInfo->filename, CFile::modeRead))
  314. {
  315. pInfo->result = ER_FILERWERR; // 打开文件时出错
  316. return;
  317. }
  319. // 获取PSD文件的长度（以字节为单位）
  320. dwFileSize = file.GetLength();
  322. // 用长度判断
  323. if (dwFileSize < sizeof(PSDFILEHEADER) )
  324. {
  325. // 这不是一个PSD文件，PSD文件的长度起码大于文件头
  326. file.Close();
  327. return;
  328. }
  330. // 读取PSD的文件头结构，并检查它们的有效性
  331. file.SeekToBegin();
  332. uReadSize  = file.Read((LPSTR)&PsdHeader, sizeof(PSDFILEHEADER));
  333. if ( uReadSize != sizeof(PSDFILEHEADER) )
  334. {
  335. pInfo->result = ER_FILERWERR; // 读文件时出错
  336. file.Close();
  337. return;
  338. }
  340. // 判断文件头部的PSD文件标志('8BPS')和Version标志(1)
  341. // PSD 的 Version 一定是 1，如果是其他的就错了
  342. if ( (PsdHeader.Signature != PSD_SIGNATURE_MARKER) ||
  343. (PsdHeader.Version != PSD_VERSION_MARKER) )
  344. {
  345. file.Close();
  346. return;
  347. }
  348. ///////////////////////////////////////////////////////////////////////////
  349. //  其实到了这里就可以说基本是PSD的图了。
  350. ///////////////////////////////////////////////////////////////////////////
  352. PsdHeader.Channels = ExchangeWord( PsdHeader.Channels ) ;
  353. PsdHeader.Rows = ExchangeDWord( PsdHeader.Rows ) ;
  354. PsdHeader.Columns = ExchangeDWord( PsdHeader.Columns ) ;
  355. PsdHeader.Depth = ExchangeWord( PsdHeader.Depth ) ;
  356. PsdHeader.Mode = ExchangeWord( PsdHeader.Mode ) ;
  358. // 通道数必须在 1 到 24 之间
  359. // 长宽的范围在 1 到 30000 之间
  360. if( PsdHeader.Channels<1 || PsdHeader.Channels>24 
  361. || PsdHeader.Rows<1 || PsdHeader.Rows>30000 
  362. || PsdHeader.Columns<1 || PsdHeader.Columns>30000 )
  363. {
  364. file.Close() ;
  365. return ;
  366. }
  368. if( IsSupportFormat( PsdHeader.Mode, PsdHeader.Depth ) )
  369. { // 文件的格式不支持(也包括是PSD但不支持的文件)
  370. file.Close() ;
  371. return ;
  372. }
  374. // 到此，大致可以表明该文件是一个有效的PSD文件，iAnnData变量设为1
  375. ///////////////////////////////////////////////////////////////////////////
  376. //  要向下判断也可以，不过比较花时间（还有好多条件）
  377. ///////////////////////////////////////////////////////////////////////////
  378. pInfo->annexdata.iAnnData = 1;
  379. pInfo->state = PKST_PASSVER; // 表示通过校验
  381. file.Close();
  382. }
  383. }
  388. // 操作命令解释函数---解释：CMD_GET_FILE_INFO命令
  389. // 获取指定文件的信息
  390. void _fnCMD_GET_FILE_INFO(INFOSTR *pInfo)
  391. {
  392. CFile file ;
  393. CFileStatus status ;
  394. PSDFILEHEADER PsdHeader ;
  395. DWORD TempData ;
  396. WORD Compression ;
  397. UINT uReadSize ;
  399. // 检验入口参数是否符合接口定义
  400. ASSERT(pInfo->result == ER_EMPTY);
  401. ASSERT(::strlen(pInfo->filename));
  402. // 此时，该文件必需是一个已存在的、并且是有效的BMP文件
  403. ASSERT(pInfo->state == PKST_PASSVER);
  404. // 客户模块必需要先将imginfo清空为0
  405. ASSERT(pInfo->imginfo.imgtype == IMT_NULL);
  407. // 打开指定文件
  408. if (!file.Open(pInfo->filename, CFile::modeRead))
  409. {
  410. pInfo->result = ER_FILERWERR;
  411. return;
  412. }
  414. // 读取PSD的文件头结构
  415. file.SeekToBegin();
  416. uReadSize  = file.Read((LPSTR)&PsdHeader, sizeof(PSDFILEHEADER));
  417. if ( uReadSize != sizeof(PSDFILEHEADER) )
  418. {
  419. pInfo->result = ER_FILERWERR; // 读文件时出错
  420. file.Close();
  421. return;
  422. }
  424. LPIMAGEINFOSTR lpImgInfoStr = &pInfo->imginfo;
  426. // 获取文件的长度、图像的宽度、高度等信息
  427. lpImgInfoStr->imgtype = IMT_RESSTATIC;
  428. lpImgInfoStr->imgformat = IMF_PSD;
  429. lpImgInfoStr->filesize = file.GetLength();
  430. lpImgInfoStr->width = ExchangeDWord(PsdHeader.Columns) ;
  431. // 图像的高度值有时可能是负值，所以使用了abs()函数
  432. lpImgInfoStr->height = (DWORD)::abs( ExchangeDWord(PsdHeader.Rows) ) ;
  433. lpImgInfoStr->bitcount = (DWORD)ExchangeWord(PsdHeader.Depth) ;
  435. ///////////////////////////////////////////////////////////////////////
  436. // Begin Read Compression Type
  437. // 读Color mode data section 的长度
  438. uReadSize = file.Read( &TempData, sizeof(DWORD) ) ;
  439. if( uReadSize != sizeof(DWORD) )
  440. {
  441. pInfo->result = ER_FILERWERR ; // 读文件时出错
  442. return ;
  443. }
  444. // 如果有调色板信息(只有 Indexed color 和 duotone 的图才又信息)
  445. TempData = ExchangeDWord( TempData ) ;
  446. if( TempData )
  447. {
  448. file.Seek( TempData, CFile::current ) ;
  449. }
  451. // 读Image resoureces Length
  452. uReadSize = file.Read( &TempData, sizeof(DWORD) ) ;
  453. if( uReadSize != sizeof(DWORD) )
  454. {
  455. pInfo->result = ER_FILERWERR ; // 读文件时出错
  456. return ;
  457. }
  458. // 跳过 Image resoureces
  459. TempData = ExchangeDWord( TempData ) ;
  460. if( TempData )
  461. {
  462. file.Seek(TempData, CFile::current);
  463. }
  465. // 读Image Layer and mask information section Length
  466. uReadSize = file.Read( &TempData, sizeof(DWORD) ) ;
  467. if( uReadSize != sizeof(DWORD) )
  468. {
  469. pInfo->result = ER_FILERWERR ; // 读文件时出错
  470. return ;
  471. }
  472. // 跳过 Image Layer and mask information section
  473. TempData = ExchangeDWord( TempData ) ;
  474. if( TempData )
  475. {
  476. file.Seek(TempData, CFile::current);
  477. }
  479. // 当图像格式对时分配内存
  480. uReadSize = file.Read( &Compression, sizeof(WORD) ) ;
  481. if( uReadSize != sizeof(WORD) )
  482. {
  483. pInfo->result = ER_FILERWERR ; // 读文件时出错
  484. return ;
  485. }
  486. Compression = ExchangeWord( Compression ) ;
  487. if( Compression )
  488. { // 这里，他虽是 RLE 8位的压缩，但可能有些不一样（与 Tiff的 RLE相同）
  489. lpImgInfoStr->compression = ICS_RLE8 ;
  490. }else
  491. { // 这里也有分 888 的RGB 和只有8位的灰度等
  492. if( PsdHeader.Depth == 1 )
  493. lpImgInfoStr->compression = ICS_RGB; // 简单了一些，做不得准的
  494. else
  495. lpImgInfoStr->compression = ICS_BITFIELDS ; // 分位的
  496. }
  497. // Read Compression Type is End
  498. // 这么长才读了一个压缩类型（对于PSD这种特殊格式的文件是不是可以不要呢？）
  499. ///////////////////////////////////////////////////////////////////////////
  501. // 每一图像行所占的字节数（DWORD对齐，并且只对非压缩位图有效）
  502. lpImgInfoStr->linesize = ExchangeWord(PsdHeader.Depth) * ExchangeDWord(PsdHeader.Columns) ;
  503. lpImgInfoStr->imgnumbers = 1; // PSD文件中只有一个图像
  504. lpImgInfoStr->imgchang = 1; // 表示不能被编辑
  506. // 获取文件最后的修改日期（月在高字节，日在低字节）
  507. file.GetStatus(status);
  508. lpImgInfoStr->year = (WORD)status.m_mtime.GetYear();
  509. lpImgInfoStr->monday = (WORD)status.m_mtime.GetMonth();
  510. lpImgInfoStr->monday <<= 8;
  511. lpImgInfoStr->monday |= (WORD)status.m_mtime.GetDay();
  513. // 获取文件最后的修改时间（字序：最高—0, 2—时，1—分，0—秒）
  514. lpImgInfoStr->time = status.m_mtime.GetHour();
  515. lpImgInfoStr->time <<= 8;
  516. lpImgInfoStr->time |= status.m_mtime.GetMinute();
  517. lpImgInfoStr->time <<= 8;
  518. lpImgInfoStr->time |= status.m_mtime.GetSecond();
  519. lpImgInfoStr->time &= 0xffffff;
  521. file.Close();
  523. // 设置出口数据
  524. pInfo->state = PKST_PASSINFO;
  525. pInfo->result = ER_SUCCESS;
  526. }
  530. // 操作命令解释函数---解释：CMD_LOAD_FROM_FILE命令
  531. // 从指定图像文件中读取数据
  532. void _fnCMD_LOAD_FROM_FILE(INFOSTR *pInfo)
  533. {
  534. // 检验入口参数是否符合接口定义
  535. ASSERT(pInfo->result == ER_EMPTY);
  536. ASSERT(::strlen(pInfo->filename));
  537. // 此时，该文件必需是一个已存在的、有效的PSD文件，并且数据包中
  538. // 含有该文件的信息（imginfo结构中）
  539. ASSERT(pInfo->state == PKST_PASSINFO);
  540. ASSERT(pInfo->imginfo.imgformat == IMF_PSD);
  541. ASSERT(pInfo->pImgInfo == NULL);
  542. // 必需设置标准图像格式信息
  543. ASSERT(pInfo->sDIBInfo.bmi.biSize == sizeof(BITMAPINFOHEADER));
  544. ASSERT(pInfo->pLineAddr != NULL);
  545. ASSERT(pInfo->_pbdata != NULL);
  547. CFile file;
  549. if (pInfo->fpProgress)
  550. {
  551. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, 6))
  552. { // 如果进度函数返回1，则说明用户想中断操作，返回。
  553. pInfo->result = ER_USERBREAK;
  554. return;
  555. }
  556. }
  558. // 打开指定文件
  559. if (!file.Open(pInfo->filename, CFile::modeRead))
  560. {
  561. pInfo->result = ER_FILERWERR;
  562. return;
  563. }
  564. file.Seek(0, CFile::begin);
  566. // 读取并转换图像到数据包中
  567. if (ReadFormPSDFile(file, pInfo) == 0)
  568. {
  569. // 成功
  570. pInfo->state = PKST_INFOANDBITS;
  571. pInfo->modify = 0;
  572. pInfo->result = ER_SUCCESS;
  573. }
  575. file.Close();
  577. if (pInfo->fpProgress) // 结束进度条，此调用不再支持用户中断
  578. (*pInfo->fpProgress)(RWPROGRESSSIZE, RWPROGRESSSIZE);
  579. }
  583. // 操作命令解释函数---解释：CMD_SAVE_TO_FILE命令
  584. // 将数据保存到指定文件中
  585. void _fnCMD_SAVE_TO_FILE(INFOSTR *pInfo)
  586. {
  587. // 这个命令不一定要解释，你可以参考本图像格式的具体境况来决定
  588. // 是否解释该命令。
  589. // 如果你想解释该命令，请在下面加入代码，并修改pInfo->result的返回值：
  590. // ----------------------------------------------------------------->
  591. // Pegasus:
  592. //     1，我认为PSD的格式特殊，即使保存也只能保存成多通道(深度)的单张背景图
  593. //     2，PhotoShop 能识别大部分的图像格式
  594. //     3，除PhotoShop 外PSD 格式的应用很少
  595. //   所以不要保存命令. &_* 我是不是有点懒，"是!!" 不要这样说我嘛！
  596. // ----------------------------------------------------------------->
  598. pInfo->result = ER_NOTSUPPORT;
  599. }
  604. // 操作命令解释函数---解释：CMD_RESIZE命令
  605. // 重新获取指定尺寸的图像位数据（只适用于矢量图像）
  606. void _fnCMD_RESIZE(INFOSTR *pInfo)
  607. {
  608. // 这个命令一般的图像读写模块不需要支持，它只适用于矢量图像，
  609. // 比如WMF、EMF之类。
  610. // 如果你想解释该命令，请在下面加入代码，并修改pInfo->result的返回值：
  611. // ----------------------------------------------------------------->
  613. pInfo->result = ER_NOTSUPPORT;
  614. }
  618. ///////////////////////////////////////////////////////////////////////////////////
  619. //////////////////    以下是 内部处理函数   ///////////////////////////////////////
  620. ///////////////////////////////////////////////////////////////////////////////////
  621. //  对了，我写的函数里的，检察一些空指针之类的错误的代码不多
  622. //
  624. /***********************************************************************************
  625. $                                                                                   $
  626. $    函数： int ReadFormPSDFile( CFile& file, LPINFOSTR pInfo)                      $
  627. $           将指定文件读入目标缓冲区                                                $
  628. $                                                                                   $
  629. $    参数： file        指定文件                                                    $
  630. $           pInfo       图像读写数据包结构指针                                      $
  631. $                                                                                   $
  632. $    返回：int 型                                                                   $
  633. $                 成功读入=0, 读文件时出错=1, 内存不足=2, 文件不支持=3              $
  634. $                                                                                   $
  635. ***********************************************************************************/
  636. int ReadFormPSDFile(CFile& file, LPINFOSTR pInfo)
  637. {
  638. /////////////////////////////////////////////////////////////////////////////////
  639. /// 变量的定义
  640. PSDFILEHEADER PsdHeader ; // PSD 文件信息头
  641. PBYTE pColorMode; // RGB调色板指针
  642. DWORD PaletteSize ; // 调色板大小
  644. PBYTE FileBuffer; // 文件的缓冲区-原始数据
  645. DWORD dwFileSize ; // 文件大小-字节单位
  646. DWORD dwImageSize ; // 图像的像素数
  648. DWORD dwReadData ; // 已读取的数据量
  650. UINT uReadSize ; // 一般变量-用于取得读取数据的大小
  651. DWORD dwTempData ; // 一般变量-用于读取 DWORD大小的数据
  653. unsigned int Compression ; // 数据格式 0-未压缩， 1-8位RLE压缩
  654. // unsigned int Channels ; // 要处理的通道数（不一定等于总的通道数）
  655. unsigned long HeightCount, WidthCount ; // Height, Width 的计数
  657. int ret_val ; // 返回值
  659. /////////////////////////////////////////////////////////////////////////////////
  660. /////////////////////////////////////////////////////////////////////////////////
  661. /// 函数的实现
  663. ret_val = 0 ; // 成功
  664. dwReadData = 0 ; // 累计已读的文件字节数
  666. // 读取PSD的文件头结构
  667. file.SeekToBegin();
  668. uReadSize  = file.Read((LPSTR)&PsdHeader, sizeof(PSDFILEHEADER));
  669. if ( uReadSize != sizeof(PSDFILEHEADER) )
  670. {
  671. pInfo->result = ER_FILERWERR; // 读文件时出错
  672. return 1;
  673. }
  674. dwReadData += uReadSize ;
  676. PsdHeader.Channels = ExchangeWord( PsdHeader.Channels ) ;
  677. PsdHeader.Rows = ExchangeDWord( PsdHeader.Rows ) ;
  678. PsdHeader.Columns = ExchangeDWord( PsdHeader.Columns ) ;
  679. PsdHeader.Depth = ExchangeWord( PsdHeader.Depth ) ;
  680. PsdHeader.Mode = ExchangeWord( PsdHeader.Mode ) ;
  682. // 读Color mode data section 的长度
  683. uReadSize = file.Read( &PaletteSize, sizeof(DWORD) ) ;
  684. PaletteSize = ExchangeDWord( PaletteSize ) ;
  685. if( uReadSize != sizeof(DWORD) )
  686. {
  687. pInfo->result = ER_FILERWERR ; // 读文件时出错
  688. return 1 ;
  689. }
  690. dwReadData += sizeof(DWORD) ;
  692. // 如果有调色板信息(只有 Indexed color 和 duotone 的图才又信息)
  693. if( PaletteSize )
  694. {
  695. pColorMode = (PBYTE)::GlobalAlloc(GPTR, PaletteSize);
  696. if( pColorMode == NULL )
  697. {
  698. pInfo->result = ER_MEMORYERR; // 内存不足
  699. return 2;
  700. }
  702. // 读调色板信息
  703. uReadSize = file.Read((void*)pColorMode, PaletteSize ) ;
  704. if( uReadSize != PaletteSize )
  705. {
  706. ::GlobalFree( pColorMode ) ;
  707. pInfo->result = ER_FILERWERR ; // 读文件时出错
  708. return 1 ;
  709. }
  710. dwReadData += PaletteSize ;
  711. }
  713. // 读Image resoureces Length
  714. uReadSize = file.Read( &dwTempData, sizeof(DWORD) ) ;
  715. dwTempData = ExchangeDWord( dwTempData ) ;
  716. if( uReadSize != sizeof(DWORD) )
  717. {
  718. pInfo->result = ER_FILERWERR ; // 读文件时出错
  719. return 1 ;
  720. }
  721. dwReadData += sizeof(DWORD) ;
  722. // 跳过 Image resoureces
  723. file.Seek(dwTempData, CFile::current);
  724. dwReadData += dwTempData ;
  727. // 读Image Layer and mask information section Length
  728. uReadSize = file.Read( &dwTempData, sizeof(DWORD) ) ;
  729. dwTempData = ExchangeDWord( dwTempData ) ;
  730. if( uReadSize != sizeof(DWORD) )
  731. {
  732. pInfo->result = ER_FILERWERR ; // 读文件时出错
  733. return 1 ;
  734. }
  735. dwReadData += sizeof(DWORD) ;
  736. // 跳过 Image Layer and mask information section
  737. file.Seek(dwTempData, CFile::current);
  738. dwReadData += dwTempData ;
  740. // 读数据的格式（有无压缩）
  741. uReadSize = file.Read( &Compression, sizeof(WORD) ) ;
  742. Compression = ExchangeWord( Compression ) ;
  743. if( uReadSize != sizeof(WORD) )
  744. {
  745. pInfo->result = ER_FILERWERR ; // 读文件时出错
  746. return 1 ;
  747. }
  748. dwReadData += sizeof( WORD ) ;
  750. dwFileSize = file.GetLength() ;
  752. /// 下面是测试 ColorMode ,ColorPixel 的值的正确性 ///
  753. if( IsSupportFormat( PsdHeader.Mode, PsdHeader.Depth ) )
  754. { // 文件的格式不支持
  755. return 3 ;
  756. }
  758. // 当图像格式对时分配内存
  759. FileBuffer = (PBYTE)::GlobalAlloc(GPTR, dwFileSize-dwReadData);
  760. if( FileBuffer == NULL )
  761. {
  762. pInfo->result = ER_MEMORYERR; // 内存不足
  763. return 2;
  764. }
  766. // 读信息
  767. uReadSize = file.Read(FileBuffer, dwFileSize-dwReadData ) ;
  768. if( uReadSize != dwFileSize-dwReadData )
  769. {
  770. ::GlobalFree( FileBuffer ) ;
  771. pInfo->result = ER_FILERWERR ; // 读文件时出错
  772. return 1 ;
  773. }
  774. ///////////////////////////////////////////////////////////////////////////
  775. // 解码
  776. DESFORMAT DesFormat ;
  777. PBYTE pColorR, pColorG, pColorB, pColorK, pR, pG, pB, pK;
  778. PBYTE pImage1, pImage2, pImage3, pImage4 ;
  779. PWORD pwDesPixel ;
  780. PBYTE pbDesPixel ;
  781. PDWORD pdwDesPixel ;
  783. dwImageSize = PsdHeader.Columns * PsdHeader.Rows ;
  784. DesFormat = _get_desformat(pInfo) ;
  785. pColorR = (PBYTE)::GlobalAlloc( GPTR, PsdHeader.Columns * 4 ) ;
  786. pColorG = pColorR + PsdHeader.Columns ;
  787. pColorB = pColorG + PsdHeader.Columns ;
  788. pColorK = pColorB + PsdHeader.Columns ;
  789. if( FileBuffer == NULL )
  790. {
  791. ::GlobalFree( FileBuffer ) ;
  792. pInfo->result = ER_MEMORYERR; // 内存不足
  793. return 2;
  794. }
  796. switch( Compression )
  797. {
  798. case 0: // 无压缩
  799. //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  800. //%%%%%%%%%%%%%%%%%%%%%%%%% 无压缩 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  801. //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  802. switch( PsdHeader.Depth )
  803. {
  804. case 1: // 位深为 1，只有 Bitmap 图才会
  805. BYTE BColor, Color ;
  806. for( HeightCount=0 ; HeightCount<PsdHeader.Rows ; HeightCount++ )
  807. { // 原来是才一个字节对齐的,我还以为是4字节呢 !  :(-=
  808. pImage1 = FileBuffer + HeightCount*((PsdHeader.Columns+7)/8) ;
  809. //pImage1 = FileBuffer + HeightCount*((PsdHeader.Columns+31)/32)*4 ;
  810. pR = pColorR ; pG = pColorG ; pB = pColorB ;
  811. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  812. {
  813. if( WidthCount%8 == 0 ) BColor = *(pImage1++) ;
  814. Color = (BColor&0x80)?0x00:0xFF ;
  815. *(pR++) = Color ;
  816. *(pG++) = Color ;
  817. *(pB++) = Color ;
  818. BColor <<= 1 ;
  819. } // 每次循环处理一个点
  820. pR = pColorR ; pG = pColorG ; pB = pColorB ;
  821. switch( DesFormat )
  822. {
  823. case DF_16_555:
  824. pwDesPixel = (WORD*)pInfo->pLineAddr[ HeightCount ] ;
  825. //pR = pColorR ; pG = pColorG ; pB = pColorB ;
  826. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  827. *(pwDesPixel++) = _cnv_rgb_to_555( *(pR++), *(pG++), *(pB++) ) ;
  828. break;
  829. case DF_16_565:
  830. pwDesPixel = (WORD*)pInfo->pLineAddr[ HeightCount ] ;
  831. //pR = pColorR ; pG = pColorG ; pB = pColorB ;
  832. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  833. *(pwDesPixel++) = _cnv_rgb_to_565( *(pR++), *(pG++), *(pB++) ) ;
  834. break;
  835. case DF_24:
  836. pbDesPixel = (BYTE*)pInfo->pLineAddr[ HeightCount ] ;
  837. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  838. {
  839. *(pbDesPixel++) = *(pR++) ;
  840. *(pbDesPixel++) = *(pG++) ;
  841. *(pbDesPixel++) = *(pB++) ;
  842. }
  843. break;
  844. case DF_32:
  845. pdwDesPixel = (DWORD*)pInfo->pLineAddr[ HeightCount ] ;
  846. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  847. *(pdwDesPixel++) = _cnv_rgb_to_888( *(pR++), *(pG++), *(pB++) ) ;
  848. break ;
  849. }
  850. } // 每次循环处理一行
  851. break ;
  852. case 8:
  853. for( HeightCount=0 ; HeightCount<PsdHeader.Rows && !ret_val ; HeightCount++ )
  854. {
  855. pImage1 = FileBuffer + HeightCount*PsdHeader.Columns ;
  856. pImage2 = pImage1 + dwImageSize ;
  857. pImage3 = pImage2 + dwImageSize ;
  858. pImage4 = pImage3 + dwImageSize ;
  859. pR = pColorR ; pG = pColorG ; pB = pColorB ;
  861. switch( PsdHeader.Mode )
  862. {
  863. case DUOTONE_Image:
  864. case GRAYSCALE_Image:
  865. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  866. {
  867. *pR = *(pImage1++) ;
  868. *(pG++) = *pR ;
  869. *(pB++) = *pR ;
  870. pR ++ ;
  871. } // 每次循环处理一个点
  872. break ;
  873. case INDEXED_Image:
  874. pImage2 = pColorMode ;
  875. pImage3 = pImage2 + 256 ;
  876. pImage4 = pImage3 + 256 ;
  877. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  878. {
  879. *(pR++) = pImage2[*pImage1] ;
  880. *(pG++) = pImage3[*pImage1] ;
  881. *(pB++) = pImage4[*pImage1] ;
  882. pImage1 ++ ;
  883. } // 每次循环处理一个点
  884. break ;
  885. case RGB_Image:
  886. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  887. {
  888. *(pR++) = *(pImage1++) ;
  889. *(pG++) = *(pImage2++) ;
  890. *(pB++) = *(pImage3++) ;
  891. } // 每次循环处理一个点
  892. break ;
  893. case CMYK_Image:
  894. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  895. {
  896. *(pR++) = *(pImage1++) ; // C
  897. *(pG++) = *(pImage2++) ; // M
  898. *(pB++) = *(pImage3++) ; // Y
  899. pImage4 ++ ; // K
  900. } // 每次循环处理一个点
  901. break ;
  902. case MULTICHANNEL_Image:
  903. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  904. { // 如果大于三个通道，则只算三个通道。
  905. if( PsdHeader.Channels>0 ) *(pR++) = *(pImage1++) ;
  906. else *(pR++) = 0 ;
  907. if( PsdHeader.Channels>2 ) *(pG++) = *(pImage2++) ;
  908. else *(pG++) = 0 ;
  909. if( PsdHeader.Channels>3 ) *(pB++) = *(pImage3++) ;
  910. else *(pB++) = 0 ;
  911. } // 每次循环处理一个点
  912. break ;
  913. case LAB_Image:
  914. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  915. {
  916. *(pR++) = *(pImage1++) ;
  917. *(pG++) = *(pImage2++) ;
  918. *(pB++) = *(pImage3++) ;
  919. } // 每次循环处理一个点
  920. break ;
  921. default:
  922. ret_val = 3 ;
  923. break ;
  924. }
  926. pR = pColorR ; pG = pColorG ; pB = pColorB ;
  927. switch( DesFormat )
  928. {
  929. case DF_16_555:
  930. pwDesPixel = (WORD*)pInfo->pLineAddr[ HeightCount ] ;
  931. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  932. *(pwDesPixel++) = _cnv_rgb_to_555( *(pR++), *(pG++), *(pB++) ) ;
  933. break;
  934. case DF_16_565:
  935. pwDesPixel = (WORD*)pInfo->pLineAddr[ HeightCount ] ;
  936. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  937. *(pwDesPixel++) = _cnv_rgb_to_565( *(pR++), *(pG++), *(pB++) ) ;
  938. break;
  939. case DF_24:
  940. pbDesPixel = (BYTE*)pInfo->pLineAddr[ HeightCount ] ;
  941. //pR = pColorR ; pG = pColorG ; pB = pColorB ;
  942. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  943. {
  944. *(pbDesPixel++) = *(pR++) ;
  945. *(pbDesPixel++) = *(pG++) ;
  946. *(pbDesPixel++) = *(pB++) ;
  947. }
  948. break;
  949. case DF_32:
  950. pdwDesPixel = (DWORD*)pInfo->pLineAddr[ HeightCount ] ;
  951. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  952. *(pdwDesPixel++) = _cnv_rgb_to_888( *(pR++), *(pG++), *(pB++) ) ;
  953. break ;
  954. }
  955. } // 每次循环处理一行
  956. break ;
  957. case 16:
  958. for( HeightCount=0 ; HeightCount<PsdHeader.Rows && !ret_val ; HeightCount++ )
  959. {
  960. pImage1 = FileBuffer + HeightCount*PsdHeader.Columns*2 ;
  961. pImage2 = pImage1 + dwImageSize * 2 ;
  962. pImage3 = pImage2 + dwImageSize * 2 ;
  963. pImage4 = pImage3 + dwImageSize * 2 ;
  964. pR = pColorR ; pG = pColorG ; pB = pColorB ;
  966. switch( PsdHeader.Mode )
  967. {
  968. case GRAYSCALE_Image:
  969. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  970. {
  971. *(pR++) = *pImage1 ;
  972. *(pG++) = *pImage1 ;
  973. *(pB++) = *pImage1 ;
  974. pImage1 += 2 ;
  975. } // 每次循环处理一个点
  976. break ;
  977. case RGB_Image:
  978. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  979. {
  980. *(pR++) = *pImage1 ;
  981. *(pG++) = *pImage2 ;
  982. *(pB++) = *pImage3 ;
  983. pImage1 += 2 ;
  984. pImage2 += 2 ;
  985. pImage3 += 2 ;
  986. } // 每次循环处理一个点
  987. break ;
  988. case CMYK_Image:
  989. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  990. {
  991. *(pR++) = *pImage1 ; // C
  992. *(pG++) = *pImage2 ; // M
  993. *(pB++) = *pImage3 ; // Y
  994. // 我把K分量丢了，不要了，因此图的颜色有些变化
  995. pImage1 += 2 ;
  996. pImage2 += 2 ;
  997. pImage3 += 2 ;
  998. pImage4 += 2 ; // K
  999. } // 每次循环处理一个点
  1000. break ;
  1001. default:
  1002. ret_val = 3 ;
  1003. break ;
  1004. }
  1006. pR = pColorR ; pG = pColorG ; pB = pColorB ;
  1007. switch( DesFormat )
  1008. {
  1009. case DF_16_555:
  1010. pwDesPixel = (WORD*)pInfo->pLineAddr[ HeightCount ] ;
  1011. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1012. *(pwDesPixel++) = _cnv_rgb_to_555( *(pR++), *(pG++), *(pB++) ) ;
  1013. break;
  1014. case DF_16_565:
  1015. pwDesPixel = (WORD*)pInfo->pLineAddr[ HeightCount ] ;
  1016. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1017. *(pwDesPixel++) = _cnv_rgb_to_565( *(pR++), *(pG++), *(pB++) ) ;
  1018. break;
  1019. case DF_24:
  1020. pbDesPixel = (BYTE*)pInfo->pLineAddr[ HeightCount ] ;
  1021. //pR = pColorR ; pG = pColorG ; pB = pColorB ;
  1022. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1023. {
  1024. *(pbDesPixel++) = *(pR++) ;
  1025. *(pbDesPixel++) = *(pG++) ;
  1026. *(pbDesPixel++) = *(pB++) ;
  1027. }
  1028. break;
  1029. case DF_32:
  1030. pdwDesPixel = (DWORD*)pInfo->pLineAddr[ HeightCount ] ;
  1031. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1032. *(pdwDesPixel++) = _cnv_rgb_to_888( *(pR++), *(pG++), *(pB++) ) ;
  1033. break ;
  1034. }
  1035. } // 每次循环处理一行
  1036. break ;
  1037. default:
  1038. ret_val = 3 ;
  1039. break ;
  1040. }
  1041. break ;
  1042. case 1: // 8位RLE压缩
  1043. //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1044. //%%%%%%%%%%%%%%%%%%%%%%%%%% 8位RLE压缩 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1045. //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  1046. if( PsdHeader.Depth == 8 )
  1047. {
  1048. PWORD pLineR, pLineG, pLineB, pLineK ;
  1049. // PBYTE pRB, pGB, pBB, pKB ; // 分别指向各个色的通道的首地址
  1050. DWORD Count, wData ;
  1051. BYTE Data ;
  1052. signed char Flag, Mark ;
  1054. pImage1 = FileBuffer + PsdHeader.Rows * PsdHeader.Channels * 2 ;
  1055. pLineR = (PWORD)FileBuffer ;
  1056. pLineG = pLineR + PsdHeader.Rows ;
  1057. pLineB = pLineG + PsdHeader.Rows ;
  1058. pLineK = pLineB + PsdHeader.Rows ;
  1059. Count = 0 ;
  1060. for( ; pLineR<=pLineK ; pLineR ++ )
  1061. {
  1062. if( pLineR == pLineG ) pImage2 = pImage1 + Count ;
  1063. if( pLineR == pLineB ) pImage3 = pImage1 + Count ;
  1064. if( pLineR == pLineK ) pImage4 = pImage1 + Count ;
  1065. wData = *pLineR ;
  1066. Count += ExchangeWord( wData ) ;
  1067. }
  1068. pLineR = (PWORD)FileBuffer ;
  1069. //////////////////////////////// 初始化完成 ////////////////////////
  1071. for( HeightCount=0 ; HeightCount<PsdHeader.Rows && !ret_val ; HeightCount++ )
  1072. {
  1074. pR = pColorR ; pG = pColorG ; pB = pColorB ; pK = pColorK ;
  1076. switch( PsdHeader.Mode )
  1077. {
  1078. case DUOTONE_Image:
  1079. case GRAYSCALE_Image:
  1080. for( WidthCount=0,Flag=-1 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1081. {
  1082. if( Flag<0 )
  1083. {
  1084. Flag = *(pImage1++) ;
  1085. if( Flag<0 )
  1086. {
  1087. if( Flag == -128 ) break ;
  1088. Flag = - Flag ;
  1089. Data = *(pImage1++) ;
  1090. Mark = 0 ;
  1091. }else
  1092. {
  1093. Mark = 1 ;
  1094. }
  1095. }
  1097. if( Flag>= 0 )
  1098. {
  1099. if( Mark ) *pR = *(pImage1++) ;
  1100. else *pR = Data ;
  1101. Flag -- ;
  1102. }
  1103. *(pG++) = *pR ;
  1104. *(pB++) = *pR ;
  1105. pR ++ ;
  1106. } // 每次循环处理一个点
  1107. break ;
  1108. case INDEXED_Image:
  1109. pImage2 = pColorMode ;
  1110. pImage3 = pImage2 + 256 ;
  1111. pImage4 = pImage3 + 256 ;
  1112. for( WidthCount=0,Flag=-1 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1113. {
  1114. if( Flag<0 )
  1115. {
  1116. Flag = *(pImage1++) ;
  1117. if( Flag<0 )
  1118. {
  1119. if( Flag == -128 ) break ;
  1120. Flag = - Flag ;
  1121. Data = *(pImage1++) ;
  1122. Mark = 0 ;
  1123. }else
  1124. {
  1125. Mark = 1 ;
  1126. }
  1127. }
  1128. if( Flag>= 0 )
  1129. {
  1130. if( Mark ) Data = *(pImage1++) ;
  1131. Flag -- ;
  1132. }
  1133. *(pR++) = pImage2[ Data ] ;
  1134. *(pG++) = pImage3[ Data ] ;
  1135. *(pB++) = pImage4[ Data ] ;
  1136. } // 每次循环处理一个点
  1137. break ;
  1138. case RGB_Image:
  1139. for( WidthCount=0,Flag=-1 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1140. {
  1141. if( Flag<0 )
  1142. {
  1143. Flag = *(pImage1++) ;
  1144. if( Flag<0 )
  1145. {
  1146. if( Flag == -128 ) break ;
  1147. Flag = - Flag ;
  1148. Data = *(pImage1++) ;
  1149. Mark = 0 ;
  1150. }else
  1151. {
  1152. Mark = 1 ;
  1153. }
  1154. }
  1155. if( Flag>= 0 )
  1156. {
  1157. if( Mark ) *(pR++) = *(pImage1++) ;
  1158. else *(pR++) = Data ;
  1159. Flag -- ;
  1160. }
  1161. } // 每次循环处理一个点
  1163. for( WidthCount=0,Flag=-1 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1164. {
  1165. if( Flag<0 )
  1166. {
  1167. Flag = *(pImage2++) ;
  1168. if( Flag<0 )
  1169. {
  1170. if( Flag == -128 ) break ;
  1171. Flag = - Flag ;
  1172. Data = *(pImage2++) ;
  1173. Mark = 0 ;
  1174. }else
  1175. {
  1176. Mark = 1 ;
  1177. }
  1178. }
  1179. if( Flag>= 0 )
  1180. {
  1181. if( Mark ) *(pG++) = *(pImage2++) ;
  1182. else *(pG++) = Data ;
  1183. Flag -- ;
  1184. }
  1185. } // 每次循环处理一个点
  1187. for( WidthCount=0,Flag=-1 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1188. {
  1189. if( Flag<0 )
  1190. {
  1191. Flag = *(pImage3++) ;
  1192. if( Flag<0 )
  1193. {
  1194. if( Flag == -128 ) break ;
  1195. Flag = - Flag ;
  1196. Data = *(pImage3++) ;
  1197. Mark = 0 ;
  1198. }else
  1199. {
  1200. Mark = 1 ;
  1201. }
  1202. }
  1203. if( Flag>= 0 )
  1204. {
  1205. if( Mark ) *(pB++) = *(pImage3++) ;
  1206. else *(pB++) = Data ;
  1207. Flag -- ;
  1208. }
  1209. } // 每次循环处理一个点
  1210. break ;
  1211. case CMYK_Image:
  1212. for( WidthCount=0,Flag=-1 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1213. {
  1214. if( Flag<0 )
  1215. {
  1216. Flag = *(pImage1++) ;
  1217. if( Flag<0 )
  1218. {
  1219. if( Flag == -128 ) break ;
  1220. Flag = - Flag ;
  1221. Data = *(pImage1++) ;
  1222. Mark = 0 ;
  1223. }else
  1224. {
  1225. Mark = 1 ;
  1226. }
  1227. }
  1228. if( Flag>= 0 )
  1229. {
  1230. if( Mark ) *(pR++) = *(pImage1++) ;
  1231. else *(pR++) = Data ;
  1232. Flag -- ;
  1233. }
  1234. } // 每次循环处理一个点
  1236. for( WidthCount=0,Flag=-1 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1237. {
  1238. if( Flag<0 )
  1239. {
  1240. Flag = *(pImage2++) ;
  1241. if( Flag<0 )
  1242. {
  1243. if( Flag == -128 ) break ;
  1244. Flag = - Flag ;
  1245. Data = *(pImage2++) ;
  1246. Mark = 0 ;
  1247. }else
  1248. {
  1249. Mark = 1 ;
  1250. }
  1251. }
  1252. if( Flag>= 0 )
  1253. {
  1254. if( Mark ) *(pG++) = *(pImage2++) ;
  1255. else *(pG++) = Data ;
  1256. Flag -- ;
  1257. }
  1258. } // 每次循环处理一个点
  1260. for( WidthCount=0,Flag=-1 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1261. {
  1262. if( Flag<0 )
  1263. {
  1264. Flag = *(pImage3++) ;
  1265. if( Flag<0 )
  1266. {
  1267. if( Flag == -128 ) break ;
  1268. Flag = - Flag ;
  1269. Data = *(pImage3++) ;
  1270. Mark = 0 ;
  1271. }else
  1272. {
  1273. Mark = 1 ;
  1274. }
  1275. }
  1276. if( Flag>= 0 )
  1277. {
  1278. if( Mark ) *(pB++) = *(pImage3++) ;
  1279. else *(pB++) = Data ;
  1280. Flag -- ;
  1281. }
  1282. } // 每次循环处理一个点
  1283. break ;
  1284. case MULTICHANNEL_Image:
  1285. for( WidthCount=0,Flag=-1 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1286. {
  1287. if( Flag<0 )
  1288. {
  1289. Flag = *(pImage1++) ;
  1290. if( Flag<0 )
  1291. {
  1292. if( Flag == -128 ) break ;
  1293. Flag = - Flag ;
  1294. Data = *(pImage1++) ;
  1295. Mark = 0 ;
  1296. }else
  1297. {
  1298. Mark = 1 ;
  1299. }
  1300. }
  1301. if( Flag>= 0 )
  1302. {
  1303. if( Mark ) *(pR++) = *(pImage1++) ;
  1304. else *(pR++) = Data ;
  1305. Flag -- ;
  1306. }
  1307. } // 每次循环处理一个点
  1309. if( PsdHeader.Channels > 1 )
  1310. {
  1311. for( WidthCount=0,Flag=-1 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1312. {
  1313. if( Flag<0 )
  1314. {
  1315. Flag = *(pImage2++) ;
  1316. if( Flag<0 )
  1317. {
  1318. if( Flag == -128 ) break ;
  1319. Flag = - Flag ;
  1320. Data = *(pImage2++) ;
  1321. Mark = 0 ;
  1322. }else
  1323. {
  1324. Mark = 1 ;
  1325. }
  1326. }
  1327. if( Flag>= 0 )
  1328. {
  1329. if( Mark ) *(pG++) = *(pImage2++) ;
  1330. else *(pG++) = Data ;
  1331. Flag -- ;
  1332. }
  1333. } // 每次循环处理一个点
  1334. }else
  1335. {
  1336. pR = pColorR ;
  1337. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1338. {
  1339. *(pG++) = *(pR++) ;
  1340. } // 每次循环处理一个点
  1341. }
  1343. if( PsdHeader.Channels > 2 )
  1344. {
  1345. for( WidthCount=0,Flag=-1 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1346. {
  1347. if( Flag<0 )
  1348. {
  1349. Flag = *(pImage3++) ;
  1350. if( Flag<0 )
  1351. {
  1352. if( Flag == -128 ) break ;
  1353. Flag = - Flag ;
  1354. Data = *(pImage3++) ;
  1355. Mark = 0 ;
  1356. }else
  1357. {
  1358. Mark = 1 ;
  1359. }
  1360. }
  1361. if( Flag>= 0 )
  1362. {
  1363. if( Mark ) *(pB++) = *(pImage3++) ;
  1364. else *(pB++) = Data ;
  1365. Flag -- ;
  1366. }
  1367. } // 每次循环处理一个点
  1368. }else
  1369. {
  1370. pR = pColorR ;
  1371. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1372. {
  1373. *(pB++) = *(pR++) ;
  1374. } // 每次循环处理一个点
  1375. }
  1376. break ;
  1377. case LAB_Image:
  1378. for( WidthCount=0,Flag=-1 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1379. {
  1380. if( Flag<0 )
  1381. {
  1382. Flag = *(pImage1++) ;
  1383. if( Flag<0 )
  1384. {
  1385. if( Flag == -128 ) break ;
  1386. Flag = - Flag ;
  1387. Data = *(pImage1++) ;
  1388. Mark = 0 ;
  1389. }else
  1390. {
  1391. Mark = 1 ;
  1392. }
  1393. }
  1394. if( Flag>= 0 )
  1395. {
  1396. // if( Mark ) *(pR++) = *(pImage1++) ;
  1397. // else *(pR++) = Data ;
  1398. // Flag -- ;
  1399. if( Mark ) *pR = *(pImage1++) ;
  1400. else *pR = Data ;
  1401. Flag -- ;
  1402. *(pG++) = *pR ; // 现在只是把Lab显示成灰度
  1403. *(pB++) = *pR ;
  1404. pR ++ ;
  1405. }
  1406. } // 每次循环处理一个点
  1407. /*
  1408. for( WidthCount=0,Flag=-1 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1409. {
  1410. if( Flag<0 )
  1411. {
  1412. Flag = *(pImage2++) ;
  1413. if( Flag<0 )
  1414. {
  1415. if( Flag == -128 ) break ;
  1416. Flag = - Flag ;
  1417. Data = *(pImage2++) ;
  1418. Mark = 0 ;
  1419. }else
  1420. {
  1421. Mark = 1 ;
  1422. }
  1423. }
  1424. if( Flag>= 0 )
  1425. {
  1426. if( Mark ) *(pG++) = *(pImage2++) ;
  1427. else *(pG++) = Data ;
  1428. Flag -- ;
  1429. }
  1430. } // 每次循环处理一个点
  1432. for( WidthCount=0,Flag=-1 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1433. {
  1434. if( Flag<0 )
  1435. {
  1436. Flag = *(pImage3++) ;
  1437. if( Flag<0 )
  1438. {
  1439. if( Flag == -128 ) break ;
  1440. Flag = - Flag ;
  1441. Data = *(pImage3++) ;
  1442. Mark = 0 ;
  1443. }else
  1444. {
  1445. Mark = 1 ;
  1446. }
  1447. }
  1448. if( Flag>= 0 )
  1449. {
  1450. if( Mark ) *(pB++) = *(pImage3++) ;
  1451. else *(pB++) = Data ;
  1452. Flag -- ;
  1453. }
  1454. } // 每次循环处理一个点
  1455. */ break ;
  1456. default:
  1457. ret_val = 3 ;
  1458. break ;
  1459. }
  1461. pR = pColorR ; pG = pColorG ; pB = pColorB ; pK = pColorK ;
  1462. switch( DesFormat )
  1463. {
  1464. case DF_16_555:
  1465. pwDesPixel = (WORD*)pInfo->pLineAddr[ HeightCount ] ;
  1466. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1467. *(pwDesPixel++) = _cnv_rgb_to_555( *(pR++), *(pG++), *(pB++) ) ;
  1468. break;
  1469. case DF_16_565:
  1470. pwDesPixel = (WORD*)pInfo->pLineAddr[ HeightCount ] ;
  1471. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1472. *(pwDesPixel++) = _cnv_rgb_to_565( *(pR++), *(pG++), *(pB++) ) ;
  1473. break;
  1474. case DF_24:
  1475. pbDesPixel = (BYTE*)pInfo->pLineAddr[ HeightCount ] ;
  1476. //pR = pColorR ; pG = pColorG ; pB = pColorB ;
  1477. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1478. {
  1479. *(pbDesPixel++) = *(pR++) ;
  1480. *(pbDesPixel++) = *(pG++) ;
  1481. *(pbDesPixel++) = *(pB++) ;
  1482. }
  1483. break;
  1484. case DF_32:
  1485. pdwDesPixel = (DWORD*)pInfo->pLineAddr[ HeightCount ] ;
  1486. for( WidthCount=0 ; WidthCount<PsdHeader.Columns ; WidthCount ++ )
  1487. *(pdwDesPixel++) = _cnv_rgb_to_888( *(pR++), *(pG++), *(pB++) ) ;
  1488. break ;
  1489. }
  1490. } // 每次循环处理一行
  1491. }
  1492. else
  1493. {
  1494. ret_val = 3 ;
  1495. }
  1496. break ;
  1497. default:
  1498. ret_val = 1 ; // 认为是文件出错
  1499. break ;
  1500. }
  1501. ::GlobalFree( pColorR ) ; // 图像行数据
  1502. ///////////////////////////////////////////////////////////////////////////
  1503. // 解码完成，(不管是否成功)释放内存（文件缓冲区和色盘）
  1504. ::GlobalFree( FileBuffer ) ; // 文件缓冲区
  1505. FileBuffer=NULL;
  1506. if( pColorMode ) // 色盘
  1507. {
  1508. ::GlobalFree( pColorMode ) ;
  1509. pColorMode = NULL ;
  1510. }
  1512. /************************************************
  1513. pImageData = (PBYTE)::GlobalAlloc(GPTR, pInfo->imginfo.width*pInfo->imginfo.height*3 );
  1514. if( pImageData == NULL )
  1515. {
  1516. pInfo->result = ER_MEMORYERR; // 内存不足
  1517. ::GlobalFree( FileBuffer ) ;
  1518. return 2;
  1519. }
  1521. // 解码
  1522. if( DecodePSDImageToBuffer( FileBuffer, pColorMode, pImageData, pInfo, &PsdHeader ) )
  1523. { // 文件的格式不支持 或 数据有错 或 都是我的错
  1524. return 3 ;
  1525. }
  1526. // 解码完成，释放内存（文件缓冲区和色盘）
  1527. ::GlobalFree( FileBuffer ) ; // 文件缓冲区
  1528. FileBuffer=NULL;
  1529. if( pColorMode ) // 色盘
  1530. {
  1531. ::GlobalFree( pColorMode ) ;
  1532. pColorMode = NULL ;
  1533. }
  1535. if( FormatImageToStandard( pImageData, pInfo) )
  1536. {
  1537. ::GlobalFree( pImageData ) ;
  1538. return 1 ;
  1539. }
  1540. ::GlobalFree( pImageData ) ;
  1541. ********************************************************/
  1542. return 0 ;
  1543. }
  1544. /***********************************************************************************
  1545. $                                                                                   $
  1546. $    函数：int IsSupportFormat( WORD ColorMode, WORD ColorPixel ) ;                 $
  1547. $          检查颜色模式和色深是否被支持                                             $
  1548. $                                                                                   $
  1549. $    参数：ColorMode   颜色的模式                                                   $
  1550. $                 Bitmap=0, Grayscale=1, Indexed=2, RGB=3,                          $
  1551. $                 CMYK=4, Multichannel=7, Duotone=8, Lab=9                          $
  1552. $          ColorPixel  颜色的位深                                                   $
  1553. $                 PSD 格式只有 1, 8, 16                                             $
  1554. $                                                                                   $
  1555. $    返回：int 型                                                                   $
  1556. $                 成功支持=0, 颜色模式不支持=1, 位深不支持=2                        $
  1557. $                                                                                   $
  1558. ***********************************************************************************/
  1559. int IsSupportFormat( WORD ColorMode, WORD ColorPixel )
  1560. {
  1561. /// 下面是测试 ColorMode ,ColorPixel 的值的正确性 ///
  1562. switch( ColorMode )
  1563. {
  1564. case 0: // Bitmap
  1565. if( ColorPixel == 1) break ;
  1566. return 2 ;
  1567. case 1: // Grayscale
  1568. if( ColorPixel == 8 || ColorPixel == 16 ) break ;
  1569. return 2 ;
  1570. case 2: // Indexed
  1571. if( ColorPixel == 8 ) break ;
  1572. return 2;
  1573. case 3: // RGB ( Only 8 or 16 byte )
  1574. if( ColorPixel == 8 || ColorPixel ==16 ) break ;
  1575. return 2 ;
  1576. case 4: // CMYK
  1577. if( ColorPixel == 8 || ColorPixel ==16 ) break ;
  1578. return 2 ;
  1579. case 7: // Multichannel
  1580. if( ColorPixel == 8 ) break ;
  1581. return 2 ;
  1582. case 8: // Duotone //按灰度的方法读取
  1583. if( ColorPixel == 8 ) break ;
  1584. return 2 ;
  1585. case 9: // Lab
  1586. if( ColorPixel == 8 ) break ;
  1587. return 2 ;
  1588. default: // Unknow -> Error
  1589. return 1 ;
  1590. }
  1591. return 0 ;
  1592. }