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

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

图形图象

开发平台：

Visual C++

IRWEngine.cpp：源码内容
  1. /********************************************************************
  3. IRWEngine.cpp - ISee图像读写引擎实现文件
  5.     版权所有(C) VCHelp-coPathway-ISee workgroup 2000 all member's
  7.     这一程序是自由软件，你可以遵照自由软件基金会出版的GNU 通用许可证
  8. 条款来修改和重新发布这一程序。或者用许可证的第二版，或者（根据你
  9. 的选择）用任何更新的版本。
  11.     发布这一程序的目的是希望它有用，但没有任何担保。甚至没有适合特定
  12. 目地的隐含的担保。更详细的情况请参阅GNU通用许可证。
  14.     你应该已经和程序一起收到一份GNU通用许可证(GPL)的副本。如果还没有，
  15. 写信给：
  16.     The Free Software Foundation, Inc.,  675  Mass Ave,  Cambridge,
  17.     MA02139,  USA
  19. 如果你在使用本软件时有什么问题或建议，用以下地址可以与我们取得联
  20. 系：
  21. http://isee.126.com
  22. http://www.vchelp.net
  23. 或：
  24. iseesoft@china.com
  26. 作  者：YZ E-mail：yzfree@sina.com
  27. Analyst E-mail：analyst@citiz.net
  29.     功能实现：图像读写插件的封装，独立的工作线程，透明的读写过程。
  31. 文件版本：
  32. Build 00009
  33. Date  2000-12-20
  35. ********************************************************************/
  37. #include "stdafx.h"
  39. #include "IRWERegTabFunction.h"
  40. #include "IRWEngineInfoList.h"
  41. #include "IRWEngine.h"
  43. #ifdef _DEBUG
  44. #define new DEBUG_NEW
  45. #undef THIS_FILE
  46. static char THIS_FILE[] = __FILE__;
  47. #endif
  50. // 图像读写引擎实体。（唯一的一个实体，不允许再定义另外的的实体）
  51. static CIRWEngine isee_img_engine;
  56. //@@@@@@@@@@@命令处理函数@@@@@@@@@@@@@@
  58. // 判断指定文件是否是能被处理的图像文件（精确型）
  59. void _fnIRWEC_IS_VALID_FILE(CReturnReceipt *lpCRRt, BOOL type = FALSE);
  60. // 获取图像文件的信息
  61. void _fnIRWEC_GET_FILE_INFO(CReturnReceipt *lpCRRt);
  62. // 将图像文件读入内存
  63. void _fnIRWEC_LOAD_FROM_FILE(CReturnReceipt *lpCRRt);
  64. // 保存图像到文件
  65. void _fnIRWEC_SAVE_TO_FILE(CReturnReceipt *lpCRRt);
  66. // 获取指定尺寸的图像
  67. void _fnIRWEC_RESIZE(CReturnReceipt *lpCRRt);
  68. // 获取拇指图
  69. void _fnIRWEC_GET_THUM_IMAGE(CReturnReceipt *lpCRRt, BOOL keepbit);
  72. //@@@@@@@@@@@命令处理函数的助手@@@@@@@@@@@
  74. int _fnIRWEC_Helper_IS_VALID_FILE(CReturnReceipt *, int);
  75. int _fnIRWEC_Helper_GET_FILE_INFO(CReturnReceipt *, int);
  79. //@@@@@@@@@@@引擎助手函数@@@@@@@@@@@
  81. // 调入指定插件
  82. int _IRWE_SureActive(int ID);
  83. // 调入所有插件
  84. int _IRWE_ActiveAll(void);
  85. // 确定指定的文件能被哪个插件处理，并返回插件的ID
  86. int _IRWE_QueryFileProcID(LPCTSTR lpFileName);
  87. // 初始化插件函数内部助手－刷新系统注册表
  88. int _IRWE_UpdateRegTab();
  89. // 建立插件信息数组
  90. int _IRWE_CreatePluginsInfoStock(void);
  91. // 销毁插件信息数组
  92. int _IRWE_DestroyPluginsInfoStock(void);
  93. // 发送命令到总命令列表
  94. int _IRWE_PostCommandToImgEngine(CReturnReceipt *lpCommand, BOOL pri=FALSE);
  95. // 从总命令队列读取命令
  96. CReturnReceipt *_IRWE_ReadCommandFromTotalList(void);
  99. // 图像读写引擎线程入口点
  100. UINT ie_ThreadEnter(LPVOID pParam);
  103. //@@@@缩放代码相关定义@@@@Add by Analyst 2000-12-19@@@@
  104. // Alpha表
  105. static QWORD s_AlphaTable[_IRWE_THUM_APLHATAB_SIZE];
  107. // Alpha表初始化
  108. void _Thum_InitAlphaTable();
  109. // 缩放接口函数
  110. void _Thum_BlitStretch(DWORD **lpDesLines, int deswidth, int desheight, 
  111. DWORD **lpSrcLines, int srcwidth, int srcheight);
  112. // 行缩放函数
  113. void _Thum_DrawScanLine(DWORD* DestAddr, DWORD* SrcAddr, 
  114. int Width, DWORD dU);
  115. void _Thum_DrawScanLineAlpha(DWORD* DestAddr, DWORD* SrcAddr, 
  116. int Width, DWORD dU, DWORD Alpha);
  117. //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
  120. #define ENGINE_ID 101 // 引擎线程标识
  121. #define INIT_ACTIVE_PLUGINS_NUM 3 // 初始调入插件个数
  124. // 引擎状态标志，用以表明图像读写引擎是否已建立。如果
  125. // 这个值是IRWES_DEATH，则说明引擎还未被建立，如果该
  126. // 是IRWES_EXIST，则说明引擎已经被建立起来了。
  127. // 注：引擎只能被创建一次，如果多次调用引擎的创建函数
  128. //     ，在调试版中将引发断言。
  129. static int m_IRWEState = IRWES_DEATH;
  131. static UINT m_EngineID = ENGINE_ID; // 引擎的ID
  132. static HANDLE m_EngineHandle = NULL; // 引擎句柄
  134. static _IRWEC_InfoList m_EngineData; // 图像读写模块信息表
  135. static BYTE m_ProcType[IRWE_PROCTYPE_SIZE]; // 引擎能处理的文件类型（用大写的文件扩展名标识，扩展名之间用逗号分隔）
  136. static int m_ProcID[IRWE_PROCID_SIZE]; // 能处理的文件类型与插件ID的对照表
  137. static int m_ProcCount; // 能处理的文件类型总数
  139. static CWinThread *ISee_pImgEngineThread = NULL; // 图像读写引擎线程指针
  140. static HANDLE m_EnterEvent; // 线程入口点事件
  141. static BOOL m_EngineWorkSignal = FALSE; // 引擎线程工作信号（TRUE—工作，FALSE—不工作）
  143. static CPtrList m_CommandList(256); // 命令队列实体
  144. static CRITICAL_SECTION  m_CLCriticalSection; // 命令队列访问关键段
  146. static CReturnReceipt *m_pCurrentReturnReceipt; // 当前正在处理的回执单
  152. //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
  153. // 图像读写引擎全局助手函数
  154. //
  156. // 获取图像读写引擎（指针类型）
  157. CIRWEngine *ISeeGetIRWEngine()
  158. {
  159. return (m_IRWEState == IRWES_DEATH) ? NULL:(CIRWEngine*)(&isee_img_engine);
  160. }
  163. // 查询图像读写引擎状态
  164. int ISeeQuestionIRWEState()
  165. {
  166. return m_IRWEState;
  167. }
  170. // 创建图像读写引擎
  171. int ISeeBeginIRWEngine()
  172. {
  173. ASSERT(ISeeQuestionIRWEState() == IRWES_DEATH); // 创建之后不能再调用此函数
  174. ASSERT(m_EngineData.GetUsedElemSize() == 0);
  176. // 建立信息库
  177. int result = _IRWE_CreatePluginsInfoStock();
  179. if (result != 0)
  180. return -1; // 引擎信息库无法创建
  182. // 创建手动、初始化状态为非信号化的事件
  183. m_EnterEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
  184. if (!m_EnterEvent)
  185. {
  186. _IRWE_DestroyPluginsInfoStock();
  187. return -2; // 无法创建同步事件
  188. }
  190. // 非信号化
  191. ::ResetEvent(m_EnterEvent);
  193. // 创建图像读写引擎
  194. if (!(ISee_pImgEngineThread = ::AfxBeginThread(ie_ThreadEnter, NULL)))
  195. {
  196. ::CloseHandle(m_EnterEvent);
  197. _IRWE_DestroyPluginsInfoStock();
  198. return -3; // 无法创建引擎线程
  199. }
  201. ISee_pImgEngineThread->m_bAutoDelete = FALSE;
  203. // 等待线程初始化完毕
  204. ::WaitForSingleObject(m_EnterEvent, 6000);
  205. ::CloseHandle(m_EnterEvent);
  207. // 初始化缩放代码所需的Alpha表
  208. _Thum_InitAlphaTable();
  210. m_EngineWorkSignal = TRUE;
  212. ASSERT(IRWES_DEATH == m_IRWEState);
  214. m_IRWEState = IRWES_EXIST;
  216. return 0; // 引擎已成功创建
  217. }
  220. // 关闭图像读写引擎
  221. void ISeeEndIRWEngine()
  222. {
  223. if (ISeeQuestionIRWEState() == IRWES_DEATH)
  224. return;
  226. isee_img_engine.Destruct();
  227. delete ISee_pImgEngineThread;
  228. }
  233. //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
  234. // 图像读写引擎接口函数
  235. //
  237. // 接口类初始化
  238. CIRWEngine::CIRWEngine()
  239. {
  240. VERIFY(this == (CIRWEngine*)&isee_img_engine); // 只能有一个实体
  242. int i;
  244. m_IRWEState = IRWES_DEATH;
  245. m_EngineID = ENGINE_ID;
  246. m_EngineHandle = NULL;
  247. m_EngineData.ZeroAllElement();
  249. ::ZeroMemory((PVOID)m_ProcType, IRWE_PROCTYPE_SIZE);
  250. for (i=0;i<IRWE_PROCID_SIZE;i++)
  251. m_ProcID[i] = -1;
  252. m_ProcCount = 0;
  253. }
  256. // 引擎析构
  257. CIRWEngine::~CIRWEngine()
  258. {
  259. if (m_IRWEState == IRWES_EXIST)
  260. Destruct();
  261. }
  264. // 暂停引擎的工作
  265. void CIRWEngine::Pause()
  266. {
  267. m_EngineWorkSignal = FALSE;
  268. }
  271. // 恢复引擎的工作
  272. void CIRWEngine::Restore()
  273. {
  274. m_EngineWorkSignal = TRUE;
  275. }
  278. // 获取能处理的文件的过滤串（用于FileDialog）
  279. LPTSTR CIRWEngine::GetFileFilterString()
  280. {
  281. ASSERT(ISeeQuestionIRWEState() == IRWES_EXIST);
  282. ASSERT(m_EngineData.GetUsedElemSize() > 0);
  284. CString cstmp;
  285. CString cstmp2;
  287. PBYTE lpTmp = (PBYTE)m_ProcType; // 文件类型描述串
  288. BYTE ProcBuf[8], tmp;
  289. int i, j;
  291. cstmp = (LPCTSTR)"所有被支持的图像文件 (";
  292. cstmp2.Empty();
  293. for (i=0;i<m_ProcCount;i++)
  294. {
  295. j = 0;
  297. while( ((tmp=*lpTmp++) != ',') && (tmp != 0) )
  298. ProcBuf[j++] = tmp;
  300. ProcBuf[j] = 0;
  301. ASSERT(j < 5);
  302. ::_strlwr((char*)ProcBuf); // 转换为小写
  304. cstmp2 += (LPCTSTR)"*.";
  305. cstmp2 += (LPCTSTR)ProcBuf;
  306. if ((i+1) != m_ProcCount)
  307. cstmp2 += (LPCTSTR)"; ";
  308. }
  309. ASSERT(cstmp2.GetLength() > 0); // 起码应该有一种图像被支持
  311. cstmp += cstmp2;
  312. cstmp += (LPCTSTR)")|";
  313. cstmp += cstmp2;
  314. cstmp += (LPCTSTR)"|";
  316. lpTmp = (PBYTE)m_ProcType; // 文件类型描述串
  318. for (i=0;i<m_ProcCount;i++)
  319. {
  320. j = 0;
  322. while( ((tmp=*lpTmp++) != ',') && (tmp != 0) )
  323. ProcBuf[j++] = tmp;
  325. ProcBuf[j] = 0;
  326. ASSERT(j < 5);
  328. cstmp += (LPCTSTR)ProcBuf;
  329. cstmp += (LPCTSTR)"文件 (";
  330. ::_strlwr((char*)ProcBuf); // 转换为小写
  331. cstmp += (LPCTSTR)"*.";
  332. cstmp += (LPCTSTR)ProcBuf;
  333. cstmp += (LPCTSTR)")|*.";
  334. cstmp += (LPCTSTR)ProcBuf;
  335. cstmp += (LPCTSTR)"|";
  336. }
  337. cstmp += (LPCTSTR)"所有文件 (*.*)|*.*||";
  339. LPTSTR lpResult = (LPTSTR)::GlobalAlloc(GPTR, cstmp.GetLength()+1);
  340. if (!lpResult)
  341. return NULL;
  343. // 复制过滤串
  344. ::CopyMemory((PVOID)lpResult, (PVOID)(LPCTSTR)cstmp, cstmp.GetLength()+1);
  346. return lpResult;
  347. }
  350. // 查询指定文件是否是能处理的图象文件（简版，只从扩展名判断）
  351. BOOL CIRWEngine::IsValidImageFile(LPCTSTR lpFileName)
  352. {
  353. // 确定指定的文件能被哪个插件处理，TRUE表示能被处理（只从扩展名上看）
  354. return (_IRWE_QueryFileProcID(lpFileName) == -1) ? FALSE:TRUE;
  355. }
  358. // 查询指定文件是否是能处理的图象文件（标准版，根据文件的内容判断）
  359. CReturnReceipt *CIRWEngine::IsValidImageFile(LPCTSTR lpFileName, BOOL type)
  360. {
  361. // 参数 BOOL type是指判断精度标志：TRUE-精确判断, FALSE-普通判断
  362. // 精确判断就是不以文件的扩展名为首要的判断标准，而是让
  363. // 所有的图像读写模块都判断一遍。这样做的好处是可以找出
  364. // 那些修改了扩展名的图像文件，但缺点是速度非常低。
  366. CReturnReceipt *lptmp = new CReturnReceipt;
  368. if (!lptmp)
  369. return NULL;
  371. lptmp->m_processing = IRWEPROC_INITING;
  373. if (type == FALSE) // 普通判断
  374. lptmp->m_command = IRWEC_IS_VALID_FILE_COMN;
  375. else
  376. { // 精确判断
  377. ASSERT(type == TRUE);
  378. lptmp->m_command = IRWEC_IS_VALID_FILE_NICETY;
  379. }
  381. ::lstrcpy((LPTSTR)lptmp->m_filename, (LPCTSTR)lpFileName);
  383. // 发送回执单至命令队列
  384. _IRWE_PostCommandToImgEngine(lptmp);
  386. // 等待
  387. while((lptmp->m_processing==IRWEPROC_FELL_IN)||(lptmp->m_processing==IRWEPROC_PROCESSING));
  389. return lptmp;
  390. }
  393. // 获取图像信息
  394. CReturnReceipt *CIRWEngine::GetImageFileInfo(LPCTSTR lpFileName)
  395. {
  396. CReturnReceipt *lptmp = new CReturnReceipt;
  398. if (!lptmp)
  399. return NULL;
  401. lptmp->m_processing = IRWEPROC_INITING;
  402. lptmp->m_command = IRWEC_GET_FILE_INFO;
  403. ::lstrcpy((LPTSTR)lptmp->m_filename, (LPCTSTR)lpFileName);
  405. // 发送回执单至命令队列
  406. _IRWE_PostCommandToImgEngine(lptmp);
  408. return lptmp;
  409. }
  412. // 获取图像信息
  413. void CIRWEngine::GetImageFileInfo(CReturnReceipt *pCRRt)
  414. {
  415. ASSERT(pCRRt);
  417. ASSERT(pCRRt->m_processing >= IRWEPROC_COMPLETE);
  418. // 注：不能重复发送同一个回执单到引擎中！也就是说同一个回执单
  419. // 不能同时执行两个或两个以上的命令
  421. #ifndef _DEBUG
  422. while(pCRRt->m_processing < IRWEPROC_COMPLETE); // 发布版用此语句替换，但将影响程序的灵敏度
  423. #endif
  425. pCRRt->m_processing = IRWEPROC_INITING;
  426. pCRRt->m_command = IRWEC_GET_FILE_INFO;
  427. ASSERT(::lstrlen((LPCTSTR)(pCRRt->m_filename)));
  428. ASSERT(pCRRt->m_data.state > PKST_NOTVER); // 必须已经通过校验
  429. _IRWE_PostCommandToImgEngine(pCRRt);
  430. }
  433. // 读入图象
  434. CReturnReceipt *CIRWEngine::LoadImageFromFile(
  435. LPCTSTR lpFileName, 
  436. BOOL pri/*命令的优先级，TRUE为高级命令，会被优先处理*/)
  437. {
  438. CReturnReceipt *lptmp = new CReturnReceipt;
  440. if (!lptmp)
  441. return NULL;
  443. lptmp->m_processing = IRWEPROC_INITING;
  444. lptmp->m_command = IRWEC_LOAD_FROM_FILE;
  445. ::lstrcpy((LPTSTR)lptmp->m_filename, (LPCTSTR)lpFileName);
  446. lptmp->m_data.state = PKST_NOTVER;
  447. _IRWE_PostCommandToImgEngine(lptmp, pri);
  449. return lptmp;
  450. }
  453. // 读入图象
  454. void CIRWEngine::LoadImageFromFile(
  455. CReturnReceipt *pCRRt, 
  456. BOOL pri/*命令的优先级，TRUE为高级命令，会被优先处理*/)
  457. {
  458. ASSERT(pCRRt);
  460. ASSERT(pCRRt->m_processing >= IRWEPROC_COMPLETE);
  461. // 注：不能重复发送同一个回执单到引擎中！也就是说同一个回执单
  462. // 不能同时执行两个或两个以上的命令
  464. #ifndef _DEBUG
  465. while(pCRRt->m_processing < IRWEPROC_COMPLETE); // 发布版用此语句替换，但将影响程序的灵敏度
  466. #endif
  468. pCRRt->m_processing = IRWEPROC_INITING;
  469. pCRRt->m_command = IRWEC_LOAD_FROM_FILE;
  470. ASSERT(pCRRt->m_filename);
  471. ASSERT(pCRRt->m_data.state > PKST_NOTVER);
  472. _IRWE_PostCommandToImgEngine(pCRRt, pri);
  473. }
  476. // 保存图象
  477. void CIRWEngine::SaveImageToFile(
  478. LPCTSTR lpNewFileName, // 新的文件的全路径
  479. CReturnReceipt *lpCRRt,
  480. LPBYTE lpSaveInfo, // 用户设定的保存参数
  481. DWORD dwSaveInfoSize)
  482. {
  483. ASSERT(lpCRRt);
  484. ASSERT(lpNewFileName);
  485. ASSERT(lpSaveInfo);
  486. ASSERT(dwSaveInfoSize < DPK_ANNEXINFOSIZE);
  487. ASSERT(lpCRRt->m_data.state >= PKST_INFOANDBITS);
  489. ASSERT(lpCRRt->m_processing >= IRWEPROC_COMPLETE);
  490. // 注：不能重复发送同一个回执单到引擎中！也就是说同一个回执单
  491. // 不能同时执行两个或两个以上的命令
  493. #ifndef _DEBUG
  494. while(lpCRRt->m_processing < IRWEPROC_COMPLETE); // 发布版用此语句替换，但将影响程序的灵敏度
  495. #endif
  497. lpCRRt->m_processing = IRWEPROC_INITING;
  498. lpCRRt->m_command = IRWEC_SAVE_TO_FILE;
  499. ::lstrcpy((LPTSTR)lpCRRt->m_filename, (LPCTSTR)lpNewFileName);
  500. ::CopyMemory((PVOID)lpCRRt->m_data.annexdata.siAnnData, (PVOID)lpSaveInfo, dwSaveInfoSize);
  502. _IRWE_PostCommandToImgEngine(lpCRRt);
  503. }
  506. // 按照指定的大小读入图象
  507. CReturnReceipt *CIRWEngine::LoadImageResize(LPCTSTR lpFileName, CSize& size)
  508. {
  509. CReturnReceipt *lptmp = new CReturnReceipt;
  511. if (!lptmp)
  512. return NULL;
  514. lptmp->m_command = IRWEC_RESIZE;
  515. ::lstrcpy((LPTSTR)lptmp->m_filename, (LPCTSTR)lpFileName);
  516. lptmp->m_processing = IRWEPROC_INITING;
  517. lptmp->m_data.state = PKST_NOTVER;
  518. lptmp->m_data.sDIBInfo.bmi.biWidth = size.cx;
  519. lptmp->m_data.sDIBInfo.bmi.biHeight = size.cy;
  520. _IRWE_PostCommandToImgEngine(lptmp);
  522. return lptmp;
  523. }
  526. // 获取图像文件的拇指图（以ISee格式(倒向32位DIB)）
  527. CReturnReceipt *CIRWEngine::GetThumImage(
  528. LPCTSTR lpFileName, // 待读取的文件名串
  529. CRect& rect, // 可以容纳拇指图的最小矩形（拇指图是按比例缩放的）
  530. BOOL keepbit, // 是否保留图像的位数据（在获取拇指图的过程中，
  531. // 整个的图像位数据都将被调入，如果该变量设为FALSE，
  532. // 则在本函数返回前将销毁这些数据。TRUE则保留）
  533. // 如果在调用本命令之前，回执单中已经存在位数据，那
  534. // 么无论此变量设为何值，位数据均不会被删除
  535. BOOL pri) // 命令的执行优先级，TRUE为高优先级命令，会被优先执行
  536. {
  537. ASSERT((lpFileName)&&(::lstrlen(lpFileName)));
  538. ASSERT(rect.Width() == rect.Height()); // 拇指图外围矩形必须是正方形
  539. ASSERT(rect.Width() >= IRWE_THUMIMAGE_MINI_SIZE);
  541. CReturnReceipt *lptmp = new CReturnReceipt;
  543. if (!lptmp)
  544. return NULL;
  546. lptmp->m_processing = IRWEPROC_INITING;
  547. lptmp->m_command = (keepbit) ? IRWEC_GET_THUMIMAGE_A_BIT:IRWEC_GET_THUMIMAGE;
  548. ::lstrcpy((LPTSTR)lptmp->m_filename, (LPCTSTR)lpFileName);
  549. lptmp->m_data.state = PKST_NOTVER;
  550. lptmp->m_thumbnails.m_thumbound = rect;
  551. lptmp->m_thumbnails.m_thumfrom  = IRWETHUM_FROM_CREATE;
  552. _IRWE_PostCommandToImgEngine(lptmp, pri);
  554. return lptmp;
  555. }
  558. // 获取图像文件的拇指图（以ISee格式(倒向32位DIB)）
  559. void CIRWEngine::GetThumImage(
  560. CReturnReceipt *pCRRt, // 待读取的文件回执单
  561. CRect& rect, // 同上，略
  562. BOOL keepbit, 
  563. BOOL pri)
  564. {
  565. ASSERT(pCRRt);
  566. ASSERT(rect.Width() == rect.Height()); // 必须是正方形
  567. ASSERT(rect.Width() >= IRWE_THUMIMAGE_MINI_SIZE);
  569. ASSERT(pCRRt->m_processing >= IRWEPROC_COMPLETE);
  570. // 注：不能重复发送同一个回执单到引擎中！也就是说同一个回执单
  571. // 不能同时执行两个或两个以上的命令
  573. #ifndef _DEBUG
  574. while(pCRRt->m_processing < IRWEPROC_COMPLETE); // 发布版用此语句替换，但将影响程序的灵敏度
  575. #endif
  577. pCRRt->m_processing = IRWEPROC_INITING;
  578. pCRRt->m_command = (keepbit) ? IRWEC_GET_THUMIMAGE_A_BIT:IRWEC_GET_THUMIMAGE;
  579. ASSERT(pCRRt->m_filename);
  580. ASSERT(pCRRt->m_data.state > PKST_NOTVER);
  581. pCRRt->m_thumbnails.m_thumbound = rect;
  582. pCRRt->m_thumbnails.m_thumfrom  = IRWETHUM_FROM_CREATE;
  583. _IRWE_PostCommandToImgEngine(pCRRt, pri);
  584. }
  587. // 销毁图像读写引擎
  588. int CIRWEngine::Destruct()
  589. {
  590. CReturnReceipt ics;
  591. HKEY hKey; // 注册表总句柄
  592. HKEY hPlugKey; // 插件句柄
  594. ics.m_command = IRWEC_IN_END;
  595. _IRWE_PostCommandToImgEngine(&ics, TRUE);
  596. VERIFY(::WaitForSingleObject(ISee_pImgEngineThread->m_hThread, INFINITE) == WAIT_OBJECT_0);
  598. m_EngineWorkSignal = FALSE;
  600. int i;
  601. LPIRWMODULEINFO lpIRWEInfo = NULL;
  603. // 打开系统注册表，用于刷新各插件PRI
  604. hKey = _IRWERTF_OpenRegTab();
  606. for (i=0;i<m_EngineData.GetUsedElemSize();i++)
  607. {
  608. lpIRWEInfo = m_EngineData.GetAt(i);
  609. ASSERT(lpIRWEInfo);
  611. if (lpIRWEInfo->m_ModuleState >= IRWEMS_CA)
  612. {
  613. // 插件已经被调入，说明可能发生过读写操作
  614. VERIFY(lpIRWEInfo->m_ModuleState == IRWEMS_CR);
  615. ASSERT(lpIRWEInfo->m_hDll);
  617. // 打开待刷新的插件句柄
  618. hPlugKey = _IRWERTF_OpenPlugins(hKey, (LPCTSTR)(lpIRWEInfo->m_ModuleName));
  620. // 刷新插件优先级值
  621. ASSERT(lpIRWEInfo->m_PRI > 10);
  622. _IRWERTF_SetPluginPRI(hPlugKey, lpIRWEInfo->m_PRI);
  624. _IRWERTF_CloseKey(hPlugKey);
  625. }
  626. }
  628. // 关闭系统注册表
  629. _IRWERTF_CloseKey(hKey);
  631. // 释放插件资源
  632. m_EngineData.Destroy();
  634. // 清理插件相关变量
  635. ::ZeroMemory((PVOID)m_ProcType, IRWE_PROCTYPE_SIZE);
  636. for (i=0;i<IRWE_PROCID_SIZE;i++)
  637. m_ProcID[i] = -1;
  638. m_ProcCount = 0;
  640. // 引擎熄火 :-D
  641. m_IRWEState = IRWES_DEATH;
  643. return 0;
  644. }
  647. // 获取插件开发者的信息
  648. int CIRWEngine::GetDeveloperInfo(LPDEVELOPERINFO *lppDevInfo)
  649. {
  650. ASSERT(ISeeQuestionIRWEState() == IRWES_EXIST);
  651. ASSERT(m_EngineData.GetUsedElemSize() > 0);
  653. LPDEVELOPERINFO lpInfo = (LPDEVELOPERINFO)::GlobalAlloc(GPTR, sizeof(DEVELOPERINFO)*(m_EngineData.GetUsedElemSize()+1));
  654. if (!lpInfo)
  655. {
  656. *lppDevInfo = NULL;
  657. return 0;
  658. }
  660. LPIRWMODULEINFO lpIRWEInfo;
  662. for (int i=0;i<m_EngineData.GetUsedElemSize();i++)
  663. {
  664. lpIRWEInfo = m_EngineData.GetAt(i);
  665. ASSERT((lpIRWEInfo)&&(lpIRWEInfo->m_SN == i));
  667. // 代码名称
  668. ::CopyMemory((PVOID)(lpInfo[i].modulename), (CONST PVOID)(lpIRWEInfo->m_ModuleName), 16);
  669. // 作者名字（多人时用逗号分隔）
  670. ::CopyMemory((PVOID)(lpInfo[i].author), (CONST PVOID)(lpIRWEInfo->m_Author), 16);
  671. // 作者电邮地址（多人时用逗号分隔）
  672. ::CopyMemory((PVOID)(lpInfo[i].EMail), (CONST PVOID)(lpIRWEInfo->m_EMail), 32);
  673. // 作者的留言信息
  674. ::CopyMemory((PVOID)(lpInfo[i].messages), (CONST PVOID)(lpIRWEInfo->m_Notion), 144);
  675. }
  677. ::lstrcpy((LPTSTR)(lpInfo[i].modulename), (LPCTSTR)_T("图像读写引擎"));
  678. ::lstrcpy((LPTSTR)(lpInfo[i].author), (LPCTSTR)_T("YZ"));
  679. ::lstrcpy((LPTSTR)(lpInfo[i].EMail), (LPCTSTR)_T("yzfree@sina.com"));
  680. ::lstrcpy((LPTSTR)(lpInfo[i].messages), (LPCTSTR)_T("咦哈！做这个破东西差点让我的脑子打结！"));
  682. *lppDevInfo = lpInfo;
  684. // 插件个数加引擎信息
  685. return m_EngineData.GetUsedElemSize()+1;
  686. }
  692. //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
  693. // 引擎的核心－－－命令泵
  694. //
  695. UINT ie_ThreadEnter(LPVOID pParam)
  696. {
  697. int exitmark = 0; // 线程结束标志
  698. CReturnReceipt *lpCRRt; // 命令包临时指针
  700. ASSERT(m_CommandList.IsEmpty());// 初创引擎，不应该有信息
  702. ::InitializeCriticalSection(&m_CLCriticalSection);
  703. m_pCurrentReturnReceipt = NULL;
  705. ::SetEvent(m_EnterEvent);
  707. while(!exitmark)
  708. {
  709. // 从命令队列中获取命令
  710. // －如果工作标志为FALSE或命令队列中没有命令，则 修眠—循环
  711. if ( (m_EngineWorkSignal == FALSE)||
  712.  ((lpCRRt=_IRWE_ReadCommandFromTotalList()) == NULL) )
  713. {
  714. ::Sleep(10); // 休眠10毫秒
  715. continue;
  716. }
  718. // 设置为当前正在处理的回执单
  719. m_pCurrentReturnReceipt = lpCRRt;
  721. // 分发命令
  722. switch(lpCRRt->GetCommand())
  723. {
  724. case IRWEC_IS_VALID_FILE_COMN: // 判断指定文件是否是能被处理的图像文件（普通型）
  725. _fnIRWEC_IS_VALID_FILE(lpCRRt, FALSE);
  726. break;
  727. case IRWEC_IS_VALID_FILE_NICETY: // 判断指定文件是否是能被处理的图像文件（精确型）
  728. _fnIRWEC_IS_VALID_FILE(lpCRRt, TRUE);
  729. break;
  730. case IRWEC_GET_FILE_INFO: // 获取图像文件的信息
  731. _fnIRWEC_GET_FILE_INFO(lpCRRt);
  732. break;
  733. case IRWEC_LOAD_FROM_FILE: // 将图像文件读入内存
  734. _fnIRWEC_LOAD_FROM_FILE(lpCRRt);
  735. break;
  736. case IRWEC_SAVE_TO_FILE: // 保存图像到文件
  737. _fnIRWEC_SAVE_TO_FILE(lpCRRt);
  738. break;
  739. case IRWEC_RESIZE: // 获取指定尺寸的图像
  740. _fnIRWEC_RESIZE(lpCRRt);
  741. break;
  742. case IRWEC_IN_END: // 结束引擎线程
  743. exitmark = 1;
  744. ::EnterCriticalSection(&m_CLCriticalSection);
  745. while(m_CommandList.GetCount() > 0)
  746. {
  747. lpCRRt = (CReturnReceipt *)(m_CommandList.RemoveHead());
  749. lpCRRt->m_processing = IRWEPROC_FAIL;
  750. lpCRRt->m_errorinfo  = IRWEERR_ENGINECLOSE;
  751. }
  752. ::LeaveCriticalSection(&m_CLCriticalSection);
  753. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  754. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  755. break;
  756. case IRWEC_GET_THUMIMAGE: // 获取拇指图
  757. _fnIRWEC_GET_THUM_IMAGE(lpCRRt, FALSE);
  758. break;
  759. case IRWEC_GET_THUMIMAGE_A_BIT: // 获取拇指图并保留位数据
  760. _fnIRWEC_GET_THUM_IMAGE(lpCRRt, TRUE);
  761. break;
  762. //case IRWEC_XXX: // 新的命令在此加入
  763. default:
  764. ASSERT(FALSE);
  765. exitmark = 1;
  766. break;
  767. }
  768. m_pCurrentReturnReceipt = NULL;
  769. }
  770. ::DeleteCriticalSection(&m_CLCriticalSection);
  772. return 0;
  773. }
  779. //#######################################################################
  780. // 助手函数
  781. //
  783. int _fnIRWEC_Helper_IS_VALID_FILE(CReturnReceipt *lpCRRt, int id)
  784. {
  785. ASSERT(id >= 0);
  786. ASSERT(lpCRRt);
  788. int result;
  789. LPIRWMODULEINFO lpIRWEInfo = m_EngineData.GetAt(id);
  791. ASSERT((lpIRWEInfo)&&(lpIRWEInfo->m_ModuleState==IRWEMS_CR));
  792. ASSERT(lpIRWEInfo->m_IRWPInterFace); // 此时对应的插件必须已被调入
  794. lpIRWEInfo->m_ModuleState = IRWEMS_CA; // 标志该插件进入工作状态
  795. lpCRRt->m_data.comm = CMD_IS_VALID_FILE;
  796. lpCRRt->m_data.result = ER_EMPTY;
  797. lpCRRt->m_data.annexdata.iAnnData = 0;
  798. ::lstrcpy(lpCRRt->m_data.filename, lpCRRt->m_filename);
  799. lpCRRt->m_data.state = PKST_NOTVER;
  800. result = lpIRWEInfo->m_IRWPInterFace((LPINFOSTR)lpCRRt);// 调用图像读写模块
  801. lpIRWEInfo->m_ModuleState = IRWEMS_CR;
  803. return result;
  804. }
  807. int _fnIRWEC_Helper_GET_FILE_INFO(CReturnReceipt *lpCRRt, int id)
  808. {
  809. ASSERT(id >= 0);
  810. ASSERT(lpCRRt);
  812. int result;
  813. LPIRWMODULEINFO lpIRWEInfo = m_EngineData.GetAt(id);
  815. ASSERT((lpIRWEInfo)&&(lpIRWEInfo->m_ModuleState==IRWEMS_CR));
  816. ASSERT(lpIRWEInfo->m_IRWPInterFace); // 此时对应的插件必须已被调入
  818. lpIRWEInfo->m_ModuleState = IRWEMS_CA;
  819. lpCRRt->m_data.comm = CMD_GET_FILE_INFO;
  820. lpCRRt->m_data.result = ER_EMPTY;
  821. ::ZeroMemory((PVOID)&(lpCRRt->m_data.imginfo), sizeof(IMAGEINFOSTR));
  822. ::lstrcpy(lpCRRt->m_data.filename, lpCRRt->m_filename);
  823. ASSERT(lpCRRt->m_data.state == PKST_PASSVER);
  824. result = lpIRWEInfo->m_IRWPInterFace((LPINFOSTR)lpCRRt);
  825. lpIRWEInfo->m_ModuleState = IRWEMS_CR;
  827. return result;
  828. }
  832. //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
  833. // 命令处理函数
  834. //
  836. // 判断指定文件是否是能被处理的图像文件
  837. void _fnIRWEC_IS_VALID_FILE(CReturnReceipt *lpCRRt, BOOL type)
  838. {
  839. ASSERT(lpCRRt);
  840. ASSERT(::lstrlen((LPCTSTR)lpCRRt->m_filename));
  841. ASSERT((lpCRRt->m_command == IRWEC_IS_VALID_FILE_COMN)||(lpCRRt->m_command == IRWEC_IS_VALID_FILE_NICETY));
  843. // 调用本函数时，回执单中不能含有图像信息及位数据!
  844. ASSERT(lpCRRt->m_data.pLineAddr == NULL);
  845. ASSERT(lpCRRt->m_data._pbdata == NULL);
  846. ASSERT(lpCRRt->m_data.pImgInfo == NULL);
  848. int result;
  850. // 简单判断该文件是否能被插件处理
  851. int id = _IRWE_QueryFileProcID((LPCTSTR)(lpCRRt->m_filename));
  853. if (id >= 0) // 如果文件的扩展名已经明确的指出了图像类型
  854. {
  855. // 确保插件被调入
  856. if (_IRWE_SureActive(id) < 0)
  857. {
  858. // 调入插件失败
  859. lpCRRt->m_errorinfo = IRWEERR_ENGINEERR;
  860. lpCRRt->m_modelID = -1;
  861. lpCRRt->m_processing = IRWEPROC_FAIL;
  862. return;
  863. }
  865. // 执行判断操作
  866. _fnIRWEC_Helper_IS_VALID_FILE(lpCRRt, id);
  868. if (lpCRRt->m_data.result != ER_SUCCESS)
  869. {
  870. lpCRRt->m_errorinfo = (IRWE_ERROR)(int)(lpCRRt->m_data.result);
  871. lpCRRt->m_modelID = -1;
  872. lpCRRt->m_processing = IRWEPROC_FAIL;
  873. return;
  874. }
  875. else
  876. {
  877. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  878. if (lpCRRt->m_data.annexdata.iAnnData == 1)
  879. {
  880. ASSERT(lpCRRt->m_data.state == PKST_PASSVER);
  881. lpCRRt->m_modelID = id; // 可以被处理则该变量值有效
  882. }
  883. else
  884. {
  885. ASSERT(lpCRRt->m_data.state == PKST_NOTVER);
  886. lpCRRt->m_modelID = -1;
  887. }
  888. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  889. // 判断指定的文件是否是能被处理的图像文件，应判断m_modelID
  890. // 是否为－1，如果是则表示不能被处理。大于等于0表示能被处理
  891. return;
  892. }
  893. }
  895. // 如果插件不能处理该文件，并且不要求精确判断，则返回不能处理
  896. if (type == FALSE)
  897. {
  898. lpCRRt->m_data.annexdata.iAnnData = 0;
  899. lpCRRt->m_data.state = PKST_NOTVER;
  900. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  901. lpCRRt->m_modelID = -1;
  902. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  903. return;
  904. }
  907. // 用户要求精确判定，调入所有的读写模块
  908. result = _IRWE_ActiveAll();
  910. if (result <= 0)
  911. {
  912. lpCRRt->m_errorinfo = IRWEERR_ENGINEERR;
  913. lpCRRt->m_modelID = -1;
  914. lpCRRt->m_processing = IRWEPROC_FAIL;
  915. return;
  916. }
  918. int i, count = result; // result=所有可用插件的个数
  920. for (i=0;i<count;i++)
  921. {
  922. // 执行判断操作
  923. _fnIRWEC_Helper_IS_VALID_FILE(lpCRRt, i);
  925. if (lpCRRt->m_data.result != ER_SUCCESS)
  926. {
  927. lpCRRt->m_errorinfo = (IRWE_ERROR)(int)(lpCRRt->m_data.result);
  928. lpCRRt->m_modelID = -1;
  929. lpCRRt->m_processing = IRWEPROC_FAIL;
  930. return;
  931. }
  932. else
  933. {
  934. if (lpCRRt->m_data.annexdata.iAnnData == 1)
  935. {
  936. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  937. lpCRRt->m_modelID   = i;
  938. lpCRRt->m_processing= IRWEPROC_COMPLETE;
  939. return;
  940. }
  941. }
  942. }
  944. ASSERT(lpCRRt->m_data.annexdata.iAnnData == 0);
  945. ASSERT(lpCRRt->m_data.state == PKST_NOTVER);
  946. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  947. lpCRRt->m_modelID = -1;
  948. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  950. return;
  951. }
  954. // 获取图像文件的信息
  955. void _fnIRWEC_GET_FILE_INFO(CReturnReceipt *lpCRRt)
  956. {
  957. ASSERT(lpCRRt);
  958. ASSERT(::lstrlen((LPCTSTR)lpCRRt->m_filename));
  959. ASSERT(lpCRRt->m_command == IRWEC_GET_FILE_INFO);
  961. int id;
  963. switch(lpCRRt->m_data.state)
  964. {
  965. case PKST_NOTVER:
  966. {
  967. // 在当前状态下，回执单中不应含有图像信息及位数据
  968. ASSERT(lpCRRt->m_data.pLineAddr == NULL);
  969. ASSERT(lpCRRt->m_data._pbdata == NULL);
  970. ASSERT(lpCRRt->m_data.pImgInfo == NULL);
  972. // 简单判断该文件是否能被插件处理
  973. id = _IRWE_QueryFileProcID((LPCTSTR)(lpCRRt->m_filename));
  975. if (id >= 0)
  976. {
  977. // 确保插件已被调入
  978. if (_IRWE_SureActive(id) < 0)
  979. {
  980. // 调入插件失败
  981. lpCRRt->m_errorinfo = IRWEERR_ENGINEERR;
  982. lpCRRt->m_modelID = -1;
  983. lpCRRt->m_processing = IRWEPROC_FAIL;
  984. return;
  985. }
  987. // 执行判断操作
  988. _fnIRWEC_Helper_IS_VALID_FILE(lpCRRt, id);
  990. if (lpCRRt->m_data.result != ER_SUCCESS)
  991. {
  992. lpCRRt->m_errorinfo = (IRWE_ERROR)(int)(lpCRRt->m_data.result);
  993. lpCRRt->m_modelID = -1;
  994. lpCRRt->m_processing = IRWEPROC_FAIL;
  995. return;
  996. }
  997. else
  998. {
  999. if (lpCRRt->m_data.annexdata.iAnnData == 0)
  1000. {
  1001. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  1002. lpCRRt->m_modelID = -1;
  1003. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  1004. return;
  1005. }
  1006. else
  1007. {
  1008. // 指定的文件可以被插件处理，转到下一个CASE
  1009. ASSERT(lpCRRt->m_data.state == PKST_PASSVER);
  1010. lpCRRt->m_modelID = id;
  1011. }
  1012. }
  1013. }
  1014. else
  1015. {
  1016. // 不能被插件处理的文件
  1017. lpCRRt->m_data.annexdata.iAnnData = 0;
  1018. lpCRRt->m_data.state = PKST_NOTVER;
  1019. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  1020. lpCRRt->m_modelID = -1;
  1021. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  1022. return;
  1023. }
  1024. }
  1025. case PKST_PASSVER:
  1026. ASSERT(lpCRRt->m_modelID >= 0);
  1028. // 在当前状态下，回执单中不应含有图像信息及位数据
  1029. ASSERT(lpCRRt->m_data.pLineAddr == NULL);
  1030. ASSERT(lpCRRt->m_data._pbdata == NULL);
  1031. ASSERT(lpCRRt->m_data.pImgInfo == NULL);
  1033. // 确保插件已被调入
  1034. if (_IRWE_SureActive(lpCRRt->m_modelID) < 0)
  1035. {
  1036. // 调入插件失败
  1037. lpCRRt->m_errorinfo = IRWEERR_ENGINEERR;
  1038. lpCRRt->m_modelID = -1;
  1039. lpCRRt->m_processing = IRWEPROC_FAIL;
  1040. return;
  1041. }
  1043. // 执行提取操作
  1044. _fnIRWEC_Helper_GET_FILE_INFO(lpCRRt, lpCRRt->m_modelID);
  1046. if (lpCRRt->m_data.result != ER_SUCCESS)
  1047. {
  1048. lpCRRt->m_errorinfo = (IRWE_ERROR)(int)(lpCRRt->m_data.result);
  1049. lpCRRt->m_processing = IRWEPROC_FAIL;
  1050. return;
  1051. }
  1052. else
  1053. {
  1054. ASSERT(lpCRRt->m_data.state == PKST_PASSINFO);
  1055. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  1056. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  1057. return;
  1058. }
  1059. case PKST_PASSINFO:
  1060. ASSERT(FALSE); // 程序出现了重复调用（该回执单已经有图像信息数据了）
  1061. VERIFY(lpCRRt->m_modelID >= 0);
  1062. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  1063. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  1064. return;
  1065. case PKST_INFOANDBITS:
  1066. default:
  1067. VERIFY(FALSE); // 不允许出现这种情况
  1068. ::AfxMessageBox((LPCTSTR)_T("程序发生异常，您现在最好关闭本程序，以免使系统崩溃。"));
  1069. lpCRRt->m_errorinfo = IRWEERR_ENGINEERR;
  1070. lpCRRt->m_modelID = -1;
  1071. lpCRRt->m_processing = IRWEPROC_FAIL;
  1072. return;
  1073. }
  1074. }
  1077. // 将图像文件读入内存
  1078. void _fnIRWEC_LOAD_FROM_FILE(CReturnReceipt *lpCRRt)
  1079. {
  1080. ASSERT(lpCRRt);
  1081. ASSERT(::lstrlen((LPCTSTR)lpCRRt->m_filename));
  1082. ASSERT(lpCRRt->m_command == IRWEC_LOAD_FROM_FILE);
  1084. int result, id, y;
  1085. LPIRWMODULEINFO lpIRWEInfo;
  1087. switch(lpCRRt->m_data.state)
  1088. {
  1089. case PKST_NOTVER:
  1090. {
  1091. // 在当前状态下，回执单中不应含有图像信息及位数据
  1092. ASSERT(lpCRRt->m_data.pLineAddr == NULL);
  1093. ASSERT(lpCRRt->m_data._pbdata == NULL);
  1094. ASSERT(lpCRRt->m_data.pImgInfo == NULL);
  1096. // 简单判断该文件是否能被插件处理
  1097. id = _IRWE_QueryFileProcID((LPCTSTR)(lpCRRt->m_filename));
  1099. if (id >= 0)
  1100. {
  1101. if (_IRWE_SureActive(id) < 0) // 确保插件已被调入
  1102. {
  1103. lpCRRt->m_errorinfo = IRWEERR_ENGINEERR;
  1104. lpCRRt->m_modelID = -1;
  1105. lpCRRt->m_processing = IRWEPROC_FAIL;
  1106. return;
  1107. }
  1109. // 执行判断操作
  1110. _fnIRWEC_Helper_IS_VALID_FILE(lpCRRt, id);
  1112. if (lpCRRt->m_data.result != ER_SUCCESS)
  1113. {
  1114. // 读写模块在执行过程中发生错误
  1115. lpCRRt->m_errorinfo = (IRWE_ERROR)(int)(lpCRRt->m_data.result);
  1116. lpCRRt->m_modelID = -1;
  1117. lpCRRt->m_processing = IRWEPROC_FAIL;
  1118. return;
  1119. }
  1120. else
  1121. {
  1122. if (lpCRRt->m_data.annexdata.iAnnData == 0)
  1123. {
  1124. // 指定文件不能被处理
  1125. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  1126. lpCRRt->m_modelID = -1;
  1127. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  1128. return;
  1129. }
  1130. else
  1131. {
  1132. ASSERT(lpCRRt->m_data.state == PKST_PASSVER);
  1133. lpCRRt->m_modelID = id; // 能处理
  1134. }
  1135. }
  1136. }
  1137. else
  1138. {
  1139. // 如果用文件的扩展名无法判断出类型，则返回
  1140. lpCRRt->m_data.annexdata.iAnnData = 0;
  1141. lpCRRt->m_data.state = PKST_NOTVER;
  1142. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  1143. lpCRRt->m_modelID = -1;
  1144. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  1145. return;
  1146. }
  1147. }
  1148. case PKST_PASSVER:
  1149. ASSERT(lpCRRt->m_modelID >= 0);
  1151. // 在当前状态下，回执单中不应含有图像信息及位数据
  1152. ASSERT(lpCRRt->m_data.pLineAddr == NULL);
  1153. ASSERT(lpCRRt->m_data._pbdata == NULL);
  1154. ASSERT(lpCRRt->m_data.pImgInfo == NULL);
  1156. // 确保插件已被调入
  1157. if (_IRWE_SureActive(lpCRRt->m_modelID) < 0)
  1158. {
  1159. // 调入插件失败
  1160. lpCRRt->m_errorinfo = IRWEERR_ENGINEERR;
  1161. lpCRRt->m_modelID = -1;
  1162. lpCRRt->m_processing = IRWEPROC_FAIL;
  1163. return;
  1164. }
  1166. // 执行提取操作
  1167. _fnIRWEC_Helper_GET_FILE_INFO(lpCRRt, lpCRRt->m_modelID);
  1169. if (lpCRRt->m_data.result != ER_SUCCESS)
  1170. {
  1171. lpCRRt->m_errorinfo = (IRWE_ERROR)(int)(lpCRRt->m_data.result);
  1172. lpCRRt->m_processing = IRWEPROC_FAIL;
  1173. return;
  1174. }
  1176. ASSERT(lpCRRt->m_data.state == PKST_PASSINFO);
  1177. case PKST_PASSINFO:
  1178. ASSERT(lpCRRt->m_modelID >= 0);
  1180. // 在当前状态下，回执单中不应含有图像信息及位数据
  1181. ASSERT(lpCRRt->m_data.pLineAddr == NULL);
  1182. ASSERT(lpCRRt->m_data._pbdata == NULL);
  1183. ASSERT(lpCRRt->m_data.pImgInfo == NULL);
  1185. lpIRWEInfo = m_EngineData.GetAt(lpCRRt->m_modelID);
  1186. ASSERT((lpIRWEInfo)&&(lpIRWEInfo->m_ModuleState==IRWEMS_CR));
  1187. ASSERT(lpIRWEInfo->m_IRWPInterFace);
  1189. lpCRRt->m_data.comm = CMD_LOAD_FROM_FILE;
  1190. lpCRRt->m_data.result = ER_EMPTY;
  1191. lpCRRt->m_data.pImgInfo = NULL;
  1192. lpCRRt->m_data.sDIBInfo.bmi.biSize     = sizeof(BITMAPINFOHEADER);
  1193. ASSERT(lpCRRt->m_data.imginfo.width  > 0);
  1194. lpCRRt->m_data.sDIBInfo.bmi.biWidth    = lpCRRt->m_data.imginfo.width;
  1195. ASSERT(lpCRRt->m_data.imginfo.height > 0);
  1196. lpCRRt->m_data.sDIBInfo.bmi.biHeight   = lpCRRt->m_data.imginfo.height;
  1197. lpCRRt->m_data.sDIBInfo.bmi.biPlanes   = 1;
  1198. lpCRRt->m_data.sDIBInfo.bmi.biBitCount = ISEE_IMAGE_BITCOUNT;// 恒定为32
  1199. lpCRRt->m_data.sDIBInfo.bmi.biCompression = BI_RGB;
  1200. lpCRRt->m_data.sDIBInfo.bmi.biSizeImage   = 0;
  1201. lpCRRt->m_data.sDIBInfo.bmi.biXPelsPerMeter = 0;
  1202. lpCRRt->m_data.sDIBInfo.bmi.biYPelsPerMeter = 0;
  1203. lpCRRt->m_data.sDIBInfo.bmi.biClrUsed       = 0;
  1204. lpCRRt->m_data.sDIBInfo.bmi.biClrImportant  = 0;
  1205. lpCRRt->m_data.sDIBInfo.rmask     = 0xff0000;
  1206. lpCRRt->m_data.sDIBInfo.gmask     = 0xff00;
  1207. lpCRRt->m_data.sDIBInfo.bmask     = 0xff;
  1208. lpCRRt->m_data.sDIBInfo.alphaMask = 0;
  1210. // 分配用于存放标准图像位数据的内存块
  1211. lpCRRt->m_data._pbdata = (PBYTE)::GlobalAlloc(GMEM_FIXED, lpCRRt->m_data.sDIBInfo.bmi.biWidth*(ISEE_IMAGE_BITCOUNT/8)*lpCRRt->m_data.sDIBInfo.bmi.biHeight);
  1212. if (!lpCRRt->m_data._pbdata)
  1213. {
  1214. lpCRRt->m_errorinfo = IRWEERR_MEMORYERR;
  1215. lpCRRt->m_processing = IRWEPROC_FAIL;
  1216. return;
  1217. }
  1219. // 分配用于存放每一扫描行地址的指针数组并初始化
  1220. lpCRRt->m_data.pLineAddr = (DWORD**)::GlobalAlloc(GPTR, lpCRRt->m_data.sDIBInfo.bmi.biHeight*sizeof(DWORD*));
  1221. if (!lpCRRt->m_data.pLineAddr)
  1222. {
  1223. ::GlobalFree(lpCRRt->m_data._pbdata);
  1224. lpCRRt->m_data._pbdata = NULL;
  1225. lpCRRt->m_errorinfo = IRWEERR_MEMORYERR;
  1226. lpCRRt->m_processing = IRWEPROC_FAIL;
  1227. return;
  1228. }
  1230. // 初始化行首数组
  1231. for (y=0;y<lpCRRt->m_data.sDIBInfo.bmi.biHeight;y++)
  1232. lpCRRt->m_data.pLineAddr[y] = (DWORD*)(lpCRRt->m_data._pbdata+((lpCRRt->m_data.sDIBInfo.bmi.biHeight-y-1)*(lpCRRt->m_data.sDIBInfo.bmi.biWidth*(ISEE_IMAGE_BITCOUNT/8))));
  1235. lpIRWEInfo->m_ModuleState = IRWEMS_CA;
  1236. if (lpIRWEInfo->m_PRI < 0xffffffff)
  1237. lpIRWEInfo->m_PRI++; // 优先级数加一
  1239. // 读取文件中的图像数据
  1240. result = lpIRWEInfo->m_IRWPInterFace((LPINFOSTR)lpCRRt);
  1241. lpIRWEInfo->m_ModuleState = IRWEMS_CR;
  1243. if (lpCRRt->m_data.result != ER_SUCCESS)
  1244. {
  1245. // 读取失败
  1246. lpCRRt->m_errorinfo = (IRWE_ERROR)(int)(lpCRRt->m_data.result);
  1247. lpCRRt->m_processing = IRWEPROC_FAIL;
  1248. return;
  1249. }
  1250. else
  1251. {
  1252. ASSERT(lpCRRt->m_data.state == PKST_INFOANDBITS);
  1253. ASSERT(lpCRRt->m_data.modify == 0);
  1254. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  1255. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  1256. return;
  1257. }
  1258. case PKST_INFOANDBITS:
  1259. ASSERT(FALSE); // 不能重复的读取图像
  1260. VERIFY(lpCRRt->m_modelID >= 0);
  1261. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  1262. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  1263. return;
  1264. default:
  1265. VERIFY(FALSE); // 不允许出现这种情况
  1266. ::AfxMessageBox((LPCTSTR)_T("程序发生异常，您现在最好关闭本程序，以免使系统崩溃。"));
  1267. lpCRRt->m_errorinfo = IRWEERR_ENGINEERR;
  1268. lpCRRt->m_modelID = -1;
  1269. lpCRRt->m_processing = IRWEPROC_FAIL;
  1270. return;
  1271. }
  1272. }
  1275. // 保存图像到文件
  1276. void _fnIRWEC_SAVE_TO_FILE(CReturnReceipt *lpCRRt)
  1277. {
  1278. ASSERT(lpCRRt->m_data.state >= PKST_INFOANDBITS);
  1279. ASSERT(lpCRRt->m_data._pbdata);
  1280. ASSERT(lpCRRt->m_data.pLineAddr);
  1281. ASSERT(::lstrlen((LPCTSTR)(lpCRRt->m_data.filename)));
  1283. int result;
  1284. LPIRWMODULEINFO lpIRWEInfo;
  1286. ASSERT(lpCRRt->m_modelID >= 0);
  1288. lpIRWEInfo = m_EngineData.GetAt(lpCRRt->m_modelID);
  1289. ASSERT((lpIRWEInfo)&&(lpIRWEInfo->m_ModuleState==IRWEMS_CR));
  1290. ASSERT(lpIRWEInfo->m_IRWPInterFace);
  1292. // 检验对应的插件是否支持保存功能
  1293. if (!(lpIRWEInfo->m_Function&0x2))
  1294. {
  1295. lpCRRt->m_errorinfo = IRWEERR_NOTSUPPORT;
  1296. lpCRRt->m_processing = IRWEPROC_FAIL;
  1297. return;
  1298. }
  1300. // 保存原始文件名
  1301. ::lstrcpy((LPTSTR)(lpCRRt->m_data.imginfo.filename), (LPCTSTR)(lpCRRt->m_data.filename));
  1302. // 设置新文件名
  1303. ::lstrcpy((LPTSTR)(lpCRRt->m_data.filename), (LPCTSTR)(lpCRRt->m_filename));
  1305. lpIRWEInfo->m_ModuleState = IRWEMS_CA;
  1306. lpCRRt->m_data.comm = CMD_SAVE_TO_FILE;
  1307. lpCRRt->m_data.result = ER_EMPTY;
  1309. ASSERT(lpCRRt->m_data._pbdata != NULL);
  1310. ASSERT(::lstrlen((LPCTSTR)(lpCRRt->m_data.filename)));
  1312. // 写文件
  1313. result = lpIRWEInfo->m_IRWPInterFace((LPINFOSTR)lpCRRt);
  1314. lpIRWEInfo->m_ModuleState = IRWEMS_CR;
  1316. if (lpCRRt->m_data.result != ER_SUCCESS)
  1317. {
  1318. lpCRRt->m_errorinfo = (IRWE_ERROR)(int)(lpCRRt->m_data.result);
  1319. lpCRRt->m_processing = IRWEPROC_FAIL;
  1320. return;
  1321. }
  1322. else
  1323. {
  1324. ASSERT(lpCRRt->m_data.modify == 0);
  1325. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  1326. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  1327. return;
  1328. }
  1329. }
  1332. // 获取指定尺寸的图像
  1333. void _fnIRWEC_RESIZE(CReturnReceipt *lpCRRt)
  1334. {
  1335. ASSERT(lpCRRt);
  1336. ASSERT(::lstrlen((LPCTSTR)lpCRRt->m_filename));
  1337. ASSERT(lpCRRt->m_command == IRWEC_RESIZE);
  1339. int result, id, y;
  1340. LPIRWMODULEINFO lpIRWEInfo;
  1342. switch(lpCRRt->m_data.state)
  1343. {
  1344. case PKST_NOTVER:
  1345. {
  1346. // 在当前状态下，回执单中不应含有图像信息及位数据
  1347. ASSERT(lpCRRt->m_data.pLineAddr == NULL);
  1348. ASSERT(lpCRRt->m_data._pbdata == NULL);
  1349. ASSERT(lpCRRt->m_data.pImgInfo == NULL);
  1351. // 简单判断该文件是否能被插件处理
  1352. id = _IRWE_QueryFileProcID((LPCTSTR)(lpCRRt->m_filename));
  1354. if (id >= 0)
  1355. {
  1356. if (_IRWE_SureActive(id) < 0) // 确保插件已被调入
  1357. {
  1358. lpCRRt->m_errorinfo = IRWEERR_ENGINEERR;
  1359. lpCRRt->m_modelID = -1;
  1360. lpCRRt->m_processing = IRWEPROC_FAIL;
  1361. return;
  1362. }
  1364. // 执行判断操作
  1365. _fnIRWEC_Helper_IS_VALID_FILE(lpCRRt, id);
  1367. if (lpCRRt->m_data.result != ER_SUCCESS)
  1368. {
  1369. // 读写模块在执行过程中发生错误
  1370. lpCRRt->m_errorinfo = (IRWE_ERROR)(int)(lpCRRt->m_data.result);
  1371. lpCRRt->m_modelID = -1;
  1372. lpCRRt->m_processing = IRWEPROC_FAIL;
  1373. return;
  1374. }
  1375. else
  1376. {
  1377. if (lpCRRt->m_data.annexdata.iAnnData == 0)
  1378. {
  1379. // 指定文件不能被处理
  1380. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  1381. lpCRRt->m_modelID = -1;
  1382. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  1383. return;
  1384. }
  1385. else
  1386. {
  1387. ASSERT(lpCRRt->m_data.state == PKST_PASSVER);
  1388. lpCRRt->m_modelID = id; // 能处理
  1389. }
  1390. }
  1391. }
  1392. else
  1393. {
  1394. // 如果用文件的扩展名无法判断出类型，则返回
  1395. lpCRRt->m_data.annexdata.iAnnData = 0;
  1396. lpCRRt->m_data.state = PKST_NOTVER;
  1397. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  1398. lpCRRt->m_modelID = -1;
  1399. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  1400. return;
  1401. }
  1402. }
  1403. case PKST_PASSVER:
  1404. ASSERT(lpCRRt->m_modelID >= 0);
  1406. // 在当前状态下，回执单中不应含有图像信息及位数据
  1407. ASSERT(lpCRRt->m_data.pLineAddr == NULL);
  1408. ASSERT(lpCRRt->m_data._pbdata == NULL);
  1409. ASSERT(lpCRRt->m_data.pImgInfo == NULL);
  1411. // 确保插件已被调入
  1412. if (_IRWE_SureActive(lpCRRt->m_modelID) < 0)
  1413. {
  1414. // 调入插件失败
  1415. lpCRRt->m_errorinfo = IRWEERR_ENGINEERR;
  1416. lpCRRt->m_modelID = -1;
  1417. lpCRRt->m_processing = IRWEPROC_FAIL;
  1418. return;
  1419. }
  1421. // 执行提取操作
  1422. _fnIRWEC_Helper_GET_FILE_INFO(lpCRRt, lpCRRt->m_modelID);
  1424. if (lpCRRt->m_data.result != ER_SUCCESS)
  1425. {
  1426. lpCRRt->m_errorinfo = (IRWE_ERROR)(int)(lpCRRt->m_data.result);
  1427. lpCRRt->m_processing = IRWEPROC_FAIL;
  1428. return;
  1429. }
  1431. ASSERT(lpCRRt->m_data.state == PKST_PASSINFO);
  1432. case PKST_PASSINFO:
  1433. ASSERT(lpCRRt->m_modelID >= 0);
  1435. // 在当前状态下，回执单中不应含有图像信息及位数据
  1436. ASSERT(lpCRRt->m_data.pLineAddr == NULL);
  1437. ASSERT(lpCRRt->m_data._pbdata == NULL);
  1438. ASSERT(lpCRRt->m_data.pImgInfo == NULL);
  1440. lpIRWEInfo = m_EngineData.GetAt(lpCRRt->m_modelID);
  1441. ASSERT((lpIRWEInfo)&&(lpIRWEInfo->m_ModuleState==IRWEMS_CR));
  1442. ASSERT(lpIRWEInfo->m_IRWPInterFace);
  1444. // 检验对应的插件是否支持ReSize功能
  1445. if (!(lpIRWEInfo->m_Function&0x4))
  1446. {
  1447. lpCRRt->m_errorinfo = IRWEERR_NOTSUPPORT;
  1448. lpCRRt->m_processing = IRWEPROC_FAIL;
  1449. return;
  1450. }
  1452. lpCRRt->m_data.comm = CMD_RESIZE;
  1453. lpCRRt->m_data.result = ER_EMPTY;
  1454. lpCRRt->m_data.pImgInfo = NULL;
  1455. lpCRRt->m_data.sDIBInfo.bmi.biSize     = sizeof(BITMAPINFOHEADER);
  1456. //lpCRRt->m_data.sDIBInfo.bmi.biWidth    = lpCRRt->m_data.imginfo.width;
  1457. //lpCRRt->m_data.sDIBInfo.bmi.biHeight   = lpCRRt->m_data.imginfo.height;
  1458. // 已经在上一级函数中由用户设定了宽度、高度值
  1459. ASSERT(lpCRRt->m_data.imginfo.width  > 0);
  1460. ASSERT(lpCRRt->m_data.imginfo.height > 0);
  1461. lpCRRt->m_data.sDIBInfo.bmi.biPlanes   = 1;
  1462. lpCRRt->m_data.sDIBInfo.bmi.biBitCount = ISEE_IMAGE_BITCOUNT;// 恒定为32
  1463. lpCRRt->m_data.sDIBInfo.bmi.biCompression = BI_RGB;
  1464. lpCRRt->m_data.sDIBInfo.bmi.biSizeImage   = 0;
  1465. lpCRRt->m_data.sDIBInfo.bmi.biXPelsPerMeter = 0;
  1466. lpCRRt->m_data.sDIBInfo.bmi.biYPelsPerMeter = 0;
  1467. lpCRRt->m_data.sDIBInfo.bmi.biClrUsed       = 0;
  1468. lpCRRt->m_data.sDIBInfo.bmi.biClrImportant  = 0;
  1469. lpCRRt->m_data.sDIBInfo.rmask     = 0xff0000;
  1470. lpCRRt->m_data.sDIBInfo.gmask     = 0xff00;
  1471. lpCRRt->m_data.sDIBInfo.bmask     = 0xff;
  1472. lpCRRt->m_data.sDIBInfo.alphaMask = 0;
  1474. // 分配用于存放标准图像位数据的内存块
  1475. lpCRRt->m_data._pbdata = (PBYTE)::GlobalAlloc(GMEM_FIXED, lpCRRt->m_data.sDIBInfo.bmi.biWidth*(ISEE_IMAGE_BITCOUNT/8)*lpCRRt->m_data.sDIBInfo.bmi.biHeight);
  1476. if (!lpCRRt->m_data._pbdata)
  1477. {
  1478. lpCRRt->m_errorinfo = IRWEERR_MEMORYERR;
  1479. lpCRRt->m_processing = IRWEPROC_FAIL;
  1480. return;
  1481. }
  1483. // 分配用于存放每一扫描行地址的指针数组并初始化
  1484. lpCRRt->m_data.pLineAddr = (DWORD**)::GlobalAlloc(GPTR, lpCRRt->m_data.sDIBInfo.bmi.biHeight*sizeof(DWORD*));
  1485. if (!lpCRRt->m_data.pLineAddr)
  1486. {
  1487. ::GlobalFree(lpCRRt->m_data._pbdata);
  1488. lpCRRt->m_data._pbdata = NULL;
  1489. lpCRRt->m_errorinfo = IRWEERR_MEMORYERR;
  1490. lpCRRt->m_processing = IRWEPROC_FAIL;
  1491. return;
  1492. }
  1494. // 初始化行首数组
  1495. for (y=0;y<lpCRRt->m_data.sDIBInfo.bmi.biHeight;y++)
  1496. lpCRRt->m_data.pLineAddr[y] = (DWORD*)(lpCRRt->m_data._pbdata+((lpCRRt->m_data.sDIBInfo.bmi.biHeight-y-1)*(lpCRRt->m_data.sDIBInfo.bmi.biWidth*(ISEE_IMAGE_BITCOUNT/8))));
  1499. lpIRWEInfo->m_ModuleState = IRWEMS_CA;
  1500. if (lpIRWEInfo->m_PRI < 0xffffffff)
  1501. lpIRWEInfo->m_PRI++; // 优先级数加一
  1503. // 读取文件中的图像数据
  1504. result = lpIRWEInfo->m_IRWPInterFace((LPINFOSTR)lpCRRt);
  1505. lpIRWEInfo->m_ModuleState = IRWEMS_CR;
  1507. if (lpCRRt->m_data.result != ER_SUCCESS)
  1508. {
  1509. // 读取失败
  1510. lpCRRt->m_errorinfo = (IRWE_ERROR)(int)(lpCRRt->m_data.result);
  1511. lpCRRt->m_processing = IRWEPROC_FAIL;
  1512. return;
  1513. }
  1514. else
  1515. {
  1516. ASSERT(lpCRRt->m_data.state == PKST_INFOANDBITS);
  1517. ASSERT(lpCRRt->m_data.modify == 0);
  1518. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  1519. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  1520. return;
  1521. }
  1522. case PKST_INFOANDBITS:
  1523. default:
  1524. VERIFY(FALSE); // 不允许出现这种情况
  1525. ::AfxMessageBox((LPCTSTR)_T("程序发生异常，您现在最好关闭本程序，以免使系统崩溃。"));
  1526. lpCRRt->m_errorinfo = IRWEERR_ENGINEERR;
  1527. lpCRRt->m_modelID = -1;
  1528. lpCRRt->m_processing = IRWEPROC_FAIL;
  1529. return;
  1530. }
  1531. }
  1534. // 获取拇指图
  1535. void _fnIRWEC_GET_THUM_IMAGE(CReturnReceipt *lpCRRt, BOOL keep)
  1536. {
  1537. ASSERT(lpCRRt);
  1538. ASSERT(::lstrlen((LPCTSTR)lpCRRt->m_filename));
  1539. ASSERT((lpCRRt->m_command == IRWEC_GET_THUMIMAGE)||(lpCRRt->m_command == IRWEC_GET_THUMIMAGE_A_BIT));
  1541. BOOL hait = TRUE; // 在调用本函数之前，回执单中是否存在位数据，假设有
  1542. int result, id, y;
  1543. LPIRWMODULEINFO lpIRWEInfo;
  1544. CRect rect1, rect2;
  1545. BOOL smark; // 缩小标志
  1546. float fy;
  1548. switch(lpCRRt->m_data.state)
  1549. {
  1550. case PKST_NOTVER:
  1551. {
  1552. // 在当前状态下，回执单中不应含有图像信息及位数据
  1553. ASSERT(lpCRRt->m_data.pLineAddr == NULL);
  1554. ASSERT(lpCRRt->m_data._pbdata == NULL);
  1555. ASSERT(lpCRRt->m_data.pImgInfo == NULL);
  1557. // 简单判断该文件是否能被插件处理
  1558. id = _IRWE_QueryFileProcID((LPCTSTR)(lpCRRt->m_filename));
  1560. if (id >= 0)
  1561. {
  1562. if (_IRWE_SureActive(id) < 0) // 确保插件已被调入
  1563. {
  1564. lpCRRt->m_errorinfo = IRWEERR_ENGINEERR;
  1565. lpCRRt->m_modelID = -1;
  1566. lpCRRt->m_processing = IRWEPROC_FAIL;
  1567. return;
  1568. }
  1570. // 执行判断操作
  1571. _fnIRWEC_Helper_IS_VALID_FILE(lpCRRt, id);
  1573. if (lpCRRt->m_data.result != ER_SUCCESS)
  1574. {
  1575. // 读写模块在执行过程中发生错误
  1576. lpCRRt->m_errorinfo = (IRWE_ERROR)(int)(lpCRRt->m_data.result);
  1577. lpCRRt->m_modelID = -1;
  1578. lpCRRt->m_processing = IRWEPROC_FAIL;
  1579. return;
  1580. }
  1581. else
  1582. {
  1583. if (lpCRRt->m_data.annexdata.iAnnData == 0)
  1584. {
  1585. // 指定文件不能被处理
  1586. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  1587. lpCRRt->m_modelID = -1;
  1588. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  1589. return;
  1590. }
  1591. else
  1592. {
  1593. ASSERT(lpCRRt->m_data.state == PKST_PASSVER);
  1594. lpCRRt->m_modelID = id; // 能处理
  1595. }
  1596. }
  1597. }
  1598. else
  1599. {
  1600. // 如果用文件的扩展名无法判断出类型，则返回
  1601. lpCRRt->m_data.annexdata.iAnnData = 0;
  1602. lpCRRt->m_data.state = PKST_NOTVER;
  1603. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  1604. lpCRRt->m_modelID = -1;
  1605. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  1606. return;
  1607. }
  1608. }
  1609. case PKST_PASSVER:
  1610. ASSERT(lpCRRt->m_modelID >= 0);
  1612. // 在当前状态下，回执单中不应含有图像信息及位数据
  1613. ASSERT(lpCRRt->m_data.pLineAddr == NULL);
  1614. ASSERT(lpCRRt->m_data._pbdata == NULL);
  1615. ASSERT(lpCRRt->m_data.pImgInfo == NULL);
  1617. // 确保插件已被调入
  1618. if (_IRWE_SureActive(lpCRRt->m_modelID) < 0)
  1619. {
  1620. // 调入插件失败
  1621. lpCRRt->m_errorinfo = IRWEERR_ENGINEERR;
  1622. lpCRRt->m_modelID = -1;
  1623. lpCRRt->m_processing = IRWEPROC_FAIL;
  1624. return;
  1625. }
  1627. // 执行提取操作
  1628. _fnIRWEC_Helper_GET_FILE_INFO(lpCRRt, lpCRRt->m_modelID);
  1630. if (lpCRRt->m_data.result != ER_SUCCESS)
  1631. {
  1632. lpCRRt->m_errorinfo = (IRWE_ERROR)(int)(lpCRRt->m_data.result);
  1633. lpCRRt->m_processing = IRWEPROC_FAIL;
  1634. return;
  1635. }
  1637. ASSERT(lpCRRt->m_data.state == PKST_PASSINFO);
  1638. case PKST_PASSINFO:
  1639. ASSERT(lpCRRt->m_modelID >= 0);
  1641. // 在当前状态下，回执单中不应含有图像信息及位数据
  1642. ASSERT(lpCRRt->m_data.pLineAddr == NULL);
  1643. ASSERT(lpCRRt->m_data._pbdata == NULL);
  1644. ASSERT(lpCRRt->m_data.pImgInfo == NULL);
  1646. lpIRWEInfo = m_EngineData.GetAt(lpCRRt->m_modelID);
  1647. ASSERT((lpIRWEInfo)&&(lpIRWEInfo->m_ModuleState==IRWEMS_CR));
  1648. ASSERT(lpIRWEInfo->m_IRWPInterFace);
  1650. lpCRRt->m_data.comm = CMD_LOAD_FROM_FILE;
  1651. lpCRRt->m_data.result = ER_EMPTY;
  1652. lpCRRt->m_data.pImgInfo = NULL;
  1653. lpCRRt->m_data.sDIBInfo.bmi.biSize     = sizeof(BITMAPINFOHEADER);
  1654. ASSERT(lpCRRt->m_data.imginfo.width  > 0);
  1655. lpCRRt->m_data.sDIBInfo.bmi.biWidth    = lpCRRt->m_data.imginfo.width;
  1656. ASSERT(lpCRRt->m_data.imginfo.height > 0);
  1657. lpCRRt->m_data.sDIBInfo.bmi.biHeight   = lpCRRt->m_data.imginfo.height;
  1658. lpCRRt->m_data.sDIBInfo.bmi.biPlanes   = 1;
  1659. lpCRRt->m_data.sDIBInfo.bmi.biBitCount = ISEE_IMAGE_BITCOUNT;// 恒定为32
  1660. lpCRRt->m_data.sDIBInfo.bmi.biCompression = BI_RGB;
  1661. lpCRRt->m_data.sDIBInfo.bmi.biSizeImage   = 0;
  1662. lpCRRt->m_data.sDIBInfo.bmi.biXPelsPerMeter = 0;
  1663. lpCRRt->m_data.sDIBInfo.bmi.biYPelsPerMeter = 0;
  1664. lpCRRt->m_data.sDIBInfo.bmi.biClrUsed       = 0;
  1665. lpCRRt->m_data.sDIBInfo.bmi.biClrImportant  = 0;
  1666. lpCRRt->m_data.sDIBInfo.rmask     = 0xff0000;
  1667. lpCRRt->m_data.sDIBInfo.gmask     = 0xff00;
  1668. lpCRRt->m_data.sDIBInfo.bmask     = 0xff;
  1669. lpCRRt->m_data.sDIBInfo.alphaMask = 0;
  1671. // 分配用于存放标准图像位数据的内存块
  1672. lpCRRt->m_data._pbdata = (PBYTE)::GlobalAlloc(GMEM_FIXED, lpCRRt->m_data.sDIBInfo.bmi.biWidth*(ISEE_IMAGE_BITCOUNT/8)*lpCRRt->m_data.sDIBInfo.bmi.biHeight);
  1673. if (!lpCRRt->m_data._pbdata)
  1674. {
  1675. lpCRRt->m_errorinfo = IRWEERR_MEMORYERR;
  1676. lpCRRt->m_processing = IRWEPROC_FAIL;
  1677. return;
  1678. }
  1680. // 分配用于存放每一扫描行地址的指针数组并初始化
  1681. lpCRRt->m_data.pLineAddr = (DWORD**)::GlobalAlloc(GPTR, lpCRRt->m_data.sDIBInfo.bmi.biHeight*sizeof(DWORD*));
  1682. if (!lpCRRt->m_data.pLineAddr)
  1683. {
  1684. ::GlobalFree(lpCRRt->m_data._pbdata);
  1685. lpCRRt->m_data._pbdata = NULL;
  1686. lpCRRt->m_errorinfo = IRWEERR_MEMORYERR;
  1687. lpCRRt->m_processing = IRWEPROC_FAIL;
  1688. return;
  1689. }
  1691. // 初始化行首数组
  1692. for (y=0;y<lpCRRt->m_data.sDIBInfo.bmi.biHeight;y++)
  1693. lpCRRt->m_data.pLineAddr[y] = (DWORD*)(lpCRRt->m_data._pbdata+((lpCRRt->m_data.sDIBInfo.bmi.biHeight-y-1)*(lpCRRt->m_data.sDIBInfo.bmi.biWidth*(ISEE_IMAGE_BITCOUNT/8))));
  1696. lpIRWEInfo->m_ModuleState = IRWEMS_CA;
  1697. if (lpIRWEInfo->m_PRI < 0xffffffff)
  1698. lpIRWEInfo->m_PRI++; // 优先级数加一
  1700. // 读取文件中的图像数据
  1701. result = lpIRWEInfo->m_IRWPInterFace((LPINFOSTR)lpCRRt);
  1702. lpIRWEInfo->m_ModuleState = IRWEMS_CR;
  1704. if (lpCRRt->m_data.result != ER_SUCCESS)
  1705. {
  1706. // 读取失败
  1707. lpCRRt->m_errorinfo = (IRWE_ERROR)(int)(lpCRRt->m_data.result);
  1708. lpCRRt->m_processing = IRWEPROC_FAIL;
  1709. return;
  1710. }
  1712. ASSERT(lpCRRt->m_data.state == PKST_INFOANDBITS);
  1713. ASSERT(lpCRRt->m_data.modify == 0);
  1715. hait = FALSE; // 说明回执单以前没有位数据
  1716. case PKST_INFOANDBITS:
  1717. {
  1718. ASSERT(lpCRRt->m_data._pbdata);
  1719. VERIFY(lpCRRt->m_modelID >= 0);
  1721. // 图像的原始尺寸
  1722. rect1.SetRect(0, 0, lpCRRt->m_data.imginfo.width, lpCRRt->m_data.imginfo.height);
  1724. smark = FALSE;
  1726. if ((rect1.Width() > lpCRRt->m_thumbnails.m_thumbound.Width())||
  1727. (rect1.Height() > lpCRRt->m_thumbnails.m_thumbound.Height()))
  1728. { // 缩小图像
  1729. rect2.SetRect(0, 0, lpCRRt->m_thumbnails.m_thumbound.Width(),
  1730. lpCRRt->m_thumbnails.m_thumbound.Height());
  1732. fy = (float)rect1.Width()/(float)rect1.Height(); // 比例因子
  1734. if (rect1.Width() > rect2.Width())
  1735. rect1.DeflateRect(0, 0, rect1.Width()-rect2.Width(), (int)((rect1.Width()-rect2.Width())/fy));
  1737. if (rect1.Height() > rect2.Height())
  1738. rect1.DeflateRect(0, 0, (int)((rect1.Height()-rect2.Height())*fy), rect1.Height()-rect2.Height());
  1740. smark = TRUE;
  1741. }
  1743. // 删除以前的拇指图
  1744. if (lpCRRt->m_thumbnails.m_thumbits)
  1745. {
  1746. ::GlobalFree(lpCRRt->m_thumbnails.m_thumbits);
  1747. ASSERT(lpCRRt->m_thumbnails.m_thumlines);
  1748. ::GlobalFree(lpCRRt->m_thumbnails.m_thumlines);
  1749. }
  1750. else
  1751. ASSERT(!lpCRRt->m_thumbnails.m_thumlines);
  1753. // 校验拇指图结构已被正确初始化
  1754. ASSERT(lpCRRt->m_thumbnails.m_thuminfo.biSize == sizeof(BITMAPINFOHEADER));
  1756. lpCRRt->m_thumbnails.m_thumbits = NULL;
  1757. lpCRRt->m_thumbnails.m_thumlines= NULL;
  1758. lpCRRt->m_thumbnails.m_thumfrom = IRWETHUM_FROM_NULL;
  1759. lpCRRt->m_thumbnails.m_thuminfo.biWidth = 0;
  1760. lpCRRt->m_thumbnails.m_thuminfo.biHeight= 0;
  1762. // 分配用于存放标准图像位数据（拇指图）的内存块
  1763. lpCRRt->m_thumbnails.m_thumbits = (PBYTE)::GlobalAlloc(GPTR, rect1.Width()*(ISEE_IMAGE_BITCOUNT/8)*rect1.Height());
  1764. if (!lpCRRt->m_thumbnails.m_thumbits)
  1765. {
  1766. if (hait == FALSE) // 本次读入的位数据
  1767. lpCRRt->ClearImageBitData(); // 返回到信息状态
  1768. lpCRRt->m_errorinfo = IRWEERR_MEMORYERR;
  1769. lpCRRt->m_processing = IRWEPROC_FAIL;
  1770. return;
  1771. }
  1773. // 分配用于存放每一扫描行地址的指针数组并初始化
  1774. lpCRRt->m_thumbnails.m_thumlines = (DWORD**)::GlobalAlloc(GPTR, rect1.Height()*sizeof(DWORD*));
  1775. if (!lpCRRt->m_thumbnails.m_thumlines)
  1776. {
  1777. ::GlobalFree(lpCRRt->m_thumbnails.m_thumbits);
  1778. lpCRRt->m_thumbnails.m_thumbits = NULL;
  1780. if (hait == FALSE) // 本次读入的位数据
  1781. lpCRRt->ClearImageBitData(); // 返回到信息状态
  1782. lpCRRt->m_errorinfo = IRWEERR_MEMORYERR;
  1783. lpCRRt->m_processing = IRWEPROC_FAIL;
  1784. return;
  1785. }
  1787. // 设置拇指图参数
  1788. lpCRRt->m_thumbnails.m_thumfrom = IRWETHUM_FROM_CREATE;
  1789. lpCRRt->m_thumbnails.m_thuminfo.biWidth = rect1.Width();
  1790. lpCRRt->m_thumbnails.m_thuminfo.biHeight= rect1.Height();
  1792. // 初始化行首数组
  1793. int y;
  1794. int width = rect1.Width(), height = rect1.Height();
  1795. PBYTE lpBits = lpCRRt->m_thumbnails.m_thumbits;
  1796. DWORD **lppd = lpCRRt->m_thumbnails.m_thumlines;
  1798. for (y=0;y<height;y++)
  1799. lppd[y] = (DWORD*)((PBYTE)lpBits+((height-y-1)*(width*(ISEE_IMAGE_BITCOUNT/8))));
  1801. if (smark == TRUE)
  1802. {
  1803. // 缩小图像
  1804. _Thum_BlitStretch(lppd, width, height, 
  1805. (DWORD**)(lpCRRt->m_data.pLineAddr), 
  1806. lpCRRt->m_data.imginfo.width, 
  1807. lpCRRt->m_data.imginfo.height);
  1808. }
  1809. else
  1810. {
  1811. // 直接拷贝
  1812. ::CopyMemory((PVOID)lpBits, (PVOID)(lpCRRt->m_data._pbdata), 
  1813. width*(ISEE_IMAGE_BITCOUNT/8)*height);
  1814. }
  1816. if (hait == FALSE)
  1817. {
  1818. // 说明回执单中的位数据是本次调用读入的
  1819. if (keep == FALSE)
  1820. {
  1821. // 不保留位数据
  1822. lpCRRt->ClearImageBitData();
  1823. }
  1824. }
  1826. lpCRRt->m_errorinfo = IRWEERR_SUCCESS;
  1827. lpCRRt->m_processing = IRWEPROC_COMPLETE;
  1828. return;
  1829. }
  1830. default:
  1831. VERIFY(FALSE); // 不允许出现这种情况
  1832. ::AfxMessageBox((LPCTSTR)_T("程序发生异常，您现在最好关闭本程序，以免使系统崩溃。"));
  1833. lpCRRt->m_errorinfo = IRWEERR_ENGINEERR;
  1834. lpCRRt->m_modelID = -1;
  1835. lpCRRt->m_processing = IRWEPROC_FAIL;
  1836. return;
  1837. }
  1838. }
  1842. //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
  1843. // 图像读写引擎内部助手函数
  1844. //
  1846. // 确保指定插件已被调入
  1847. int _IRWE_SureActive(int ID)
  1848. {
  1849. // 引擎必需有一个以上的插件支持
  1850. ASSERT(m_EngineData.GetUsedElemSize());
  1852. CString dllpath;
  1854. ASSERT(ID < m_EngineData.GetUsedElemSize());
  1856. LPIRWMODULEINFO lpIRWEInfo = m_EngineData.GetAt(ID);
  1858. ASSERT(lpIRWEInfo);
  1860. if (lpIRWEInfo->m_ModuleState != IRWEMS_NULL)
  1861. {
  1862. ASSERT(lpIRWEInfo->m_SN == ID);
  1863. ASSERT(lpIRWEInfo->m_hDll);
  1864. ASSERT(lpIRWEInfo->m_IRWPInterFace);
  1865. return 1; // 已调入的插件
  1866. }
  1868. // 组合插件文件的全路径
  1869. dllpath = lpIRWEInfo->m_Path;
  1870. dllpath += lpIRWEInfo->m_FileName;
  1871. ASSERT(dllpath.GetLength());
  1873. // 此时m_hDll应该是NULL
  1874. ASSERT(!(lpIRWEInfo->m_hDll));
  1876. // 读入插件（实际上就是读入DLL）
  1877. lpIRWEInfo->m_hDll = ::LoadLibrary(dllpath);
  1878. if (lpIRWEInfo->m_hDll == NULL)
  1879. return -1; // 指定的DLL文件不存在或损坏
  1881. // 填写DLL接口函数地址
  1882. lpIRWEInfo->m_IRWPInterFace = (IRWP_INTERFACE)::GetProcAddress(
  1883. lpIRWEInfo->m_hDll, 
  1884. MAKEINTRESOURCE(1));
  1885. if (!(lpIRWEInfo->m_IRWPInterFace))
  1886. {
  1887. // 如果找不到接口函数，则返回-2
  1888. ::FreeLibrary(lpIRWEInfo->m_hDll);
  1889. lpIRWEInfo->m_hDll = NULL;
  1890. return -2; // 指定的DLL文件不是合法的ISee图像读写插件
  1891. }
  1893. // 设置模块状态（IRWEMS_CR-创建并空闲）
  1894. lpIRWEInfo->m_ModuleState = IRWEMS_CR;
  1896. // 已调入插件数加一
  1897. m_EngineData.m_Active++;
  1899. ASSERT(m_EngineData.m_Active <= m_EngineData.GetUsedElemSize());
  1901. return 0; // 成功调入
  1902. }
  1905. // 调入所有插件
  1906. int _IRWE_ActiveAll()
  1907. {
  1908. // 引擎必需有一个以上的插件支持
  1909. ASSERT(m_EngineData.GetUsedElemSize());
  1911. LPIRWMODULEINFO lpIRWEInfo;
  1912. CString dllpath;
  1913. int i = 0; 
  1914. int iUsed = m_EngineData.GetUsedElemSize();
  1916. // 如果所有插件都已经被调入，则直接返回
  1917. if (m_EngineData.GetActiveElemSize() == iUsed)
  1918. return iUsed;
  1920. // 激活插件
  1921. for (i=0;i<iUsed;i++)
  1922. {
  1923. lpIRWEInfo = m_EngineData.GetAt(i);
  1924. ASSERT(lpIRWEInfo);
  1926. if (lpIRWEInfo->m_ModuleState != IRWEMS_NULL)
  1927. continue; // 跨过已调入的插件
  1929. // 组合插件文件的全路径
  1930. dllpath = lpIRWEInfo->m_Path;
  1931. dllpath += lpIRWEInfo->m_FileName;
  1932. ASSERT(dllpath.GetLength());
  1934. // 此时m_hDll应该是NULL
  1935. ASSERT(!lpIRWEInfo->m_hDll);
  1937. // 填写DLL句柄
  1938. lpIRWEInfo->m_hDll = ::LoadLibrary((LPCTSTR)dllpath);
  1939. if (lpIRWEInfo->m_hDll == NULL)
  1940. return -1; // 指定的DLL文件不存在
  1942. // 填写DLL接口函数地址
  1943. lpIRWEInfo->m_IRWPInterFace = (IRWP_INTERFACE)::GetProcAddress(
  1944. lpIRWEInfo->m_hDll, 
  1945. MAKEINTRESOURCE(1));
  1946. if (!lpIRWEInfo->m_IRWPInterFace)
  1947. {
  1948. ::FreeLibrary(lpIRWEInfo->m_hDll);
  1949. lpIRWEInfo->m_hDll = NULL;
  1950. return -2; // 指定的DLL文件不是合法的ISee图像读写插件
  1951. }
  1953. // 设置模块状态（IRWEMS_CR-创建但空闲）
  1954. lpIRWEInfo->m_ModuleState = IRWEMS_CR;
  1956. // 已调入插件数加一
  1957. m_EngineData.m_Active++;
  1958. }
  1960. ASSERT(m_EngineData.m_Active == m_EngineData.m_Count);
  1962. return m_EngineData.m_Active;
  1963. }
  1966. // 确定指定的文件能被哪个插件处理，并返回插件的ID
  1967. int _IRWE_QueryFileProcID(LPCTSTR lpFileName)
  1968. {
  1969. ASSERT((lpFileName)&&(::lstrlen(lpFileName)));
  1970. ASSERT(m_ProcCount > 0);
  1972. int i, j;
  1973. BYTE ext[_MAX_EXT];
  1975. ::_splitpath(lpFileName, NULL, NULL, NULL, (char*)ext);
  1976. ::memmove((void*)ext, (const void*)&(ext[1]), ::lstrlen((LPCTSTR)ext));
  1977. if ((::lstrlen((LPCTSTR)ext) == 0)||(::lstrlen((LPCTSTR)ext) > 4)) // 插件只能处理扩展名小于等于4个字母的图像文件
  1978. return -1;
  1980. // 将文件扩展名转换为大写（因为插件只识别大写的扩展名）
  1981. ::_strupr((char*)ext);
  1983. PBYTE lpTmp = (PBYTE)m_ProcType;
  1984. BYTE ProcBuf[8], tmp;
  1986. for (i=0;i<m_ProcCount;i++)
  1987. {
  1988. j = 0;
  1990. while( ((tmp = *lpTmp++) != ',') && (tmp != 0) )
  1991. ProcBuf[j++] = tmp;
  1993. ProcBuf[j] = 0;
  1995. ASSERT(j < 5);
  1997. if (!::memcmp((const void*)ext, (const void*)ProcBuf, ::lstrlen((LPCTSTR)ProcBuf)+1))
  1998. return m_ProcID[i]; // 返回插件ID号（ID号都大于等于0）
  1999. }
  2000. // 未找到能处理该类型文件的插件，返回-1
  2001. return -1;
  2002. }
  2005. // 建立插件信息数组及初始化插件线程
  2006. int _IRWE_CreatePluginsInfoStock()
  2007. {
  2008. ASSERT(m_EngineData.GetUsedElemSize() == 0); // 本函数只能调用一次
  2010. CFile file;
  2011. CString dllpath;
  2012. BOOL loopcount = FALSE; // 循环标志，当变为TRUE时，表示注册表的信息已被刷新
  2013. PBYTE pbyNames = NULL;
  2014. BYTE byNames = 0;
  2015. LPTSTR pNames = NULL;
  2016. LPTSTR pPath = NULL;
  2017. LPTSTR pFN = NULL;
  2018. LPIRWMODULEINFO lpIRWEInfo = NULL;
  2020. DWORD curPRI = 0;
  2021. int Active[INIT_ACTIVE_PLUGINS_NUM];
  2022. BYTE ProcBuf[8];
  2024. PLUGSIN plugsaddinfo; // 插件文件附加信息结构
  2026. int i, j, k, iCurrent = 0, ActiveNum = 0;
  2028. HKEY hKey = NULL; // 插件信息根句柄
  2029. HKEY hPluginsKey = NULL; // 插件句柄
  2030. DWORD dwPluginsCount = 0; // 插件个数
  2032. begin:
  2033. // 初始化相关变量
  2034. dllpath.Empty();
  2035. ::ZeroMemory((PVOID)ProcBuf, 8);
  2036. ::ZeroMemory((PVOID)Active, sizeof(int)*INIT_ACTIVE_PLUGINS_NUM);
  2037. ::ZeroMemory((PVOID)&plugsaddinfo, sizeof(PLUGSIN));
  2038. m_EngineData.ZeroAllElement();
  2039. ::ZeroMemory((PVOID)m_ProcType, IRWE_PROCTYPE_SIZE);
  2040. for (i=0;i<IRWE_PROCID_SIZE;i++)
  2041. m_ProcID[i] = -1;
  2042. m_ProcCount = 0;
  2045. // 打开插件信息句柄（系统注册表）
  2046. hKey = _IRWERTF_OpenRegTab();
  2047. if (!hKey)
  2048. goto update;
  2050. // 获取插件个数
  2051. dwPluginsCount = _IRWERTF_GetPluginNumber(hKey);
  2052. if ((dwPluginsCount == 0)||((int)dwPluginsCount > m_EngineData.GetMaxElemSize()))
  2053. goto update;
  2055. VERIFY((m_EngineData.AddElement(dwPluginsCount)) == (int)dwPluginsCount);
  2058. // 获取模块名子串
  2059. pNames = _IRWERTF_GetPluginNames(hKey);
  2060. if (!pNames)
  2061. goto update;
  2063. VERIFY(::lstrlen((LPCTSTR)pNames));
  2065. pbyNames = (PBYTE)pNames;
  2066. byNames = 0;
  2067. iCurrent = 0;
  2069. // 分解模块名子串，并填写模块名
  2070. while((byNames = *pbyNames++) != '')
  2071. {
  2072. if (byNames == ' ')
  2073. continue;
  2075. i = 0;
  2077. lpIRWEInfo = m_EngineData.GetAt(iCurrent);
  2078. ASSERT(lpIRWEInfo);
  2080. do
  2081. {
  2082. lpIRWEInfo->m_ModuleName[i++] = byNames;
  2083. VERIFY(i <= 16);
  2085. byNames = *pbyNames++;
  2087. }while( (byNames != ' ')&&(byNames != '') );
  2089. lpIRWEInfo->m_ModuleName[i] = '';
  2091. if (++iCurrent > (int)dwPluginsCount)
  2092. goto update;
  2094. if (byNames == ' ')
  2095. continue;
  2097. ASSERT(byNames == '');
  2098. break;
  2099. }
  2101. ::GlobalFree(pNames); pNames = NULL;
  2103. VERIFY(iCurrent == (int)dwPluginsCount);
  2106. // 获取插件文件所在目录
  2107. pPath = _IRWERTF_GetPluginsPath(hKey);
  2108. if (!pPath)
  2109. goto update;
  2111. VERIFY(::lstrlen((LPCTSTR)pPath));
  2112. // 路径的最后一个字符必需是""符号
  2113. VERIFY(pPath[::lstrlen((LPCTSTR)pPath)-1] == '\');
  2115. // 获取并填写插件文件名、路径及优先级值
  2116. for (i=0;i<(int)dwPluginsCount;i++)
  2117. {
  2118. lpIRWEInfo = m_EngineData.GetAt(i);
  2119. ASSERT(lpIRWEInfo);
  2121. hPluginsKey = _IRWERTF_OpenPlugins(hKey, (LPCTSTR)(lpIRWEInfo->m_ModuleName));
  2122. if (hPluginsKey == NULL)
  2123. goto update;
  2125. // 填写插件优先级值
  2126. lpIRWEInfo->m_PRI = _IRWERTF_GetPluginPRI(hPluginsKey);
  2127. if (lpIRWEInfo->m_PRI < 10) // 优先级最小为10
  2128. goto update;
  2130. // 获取插件文件名子串
  2131. pFN = _IRWERTF_GetPluginsFileName(hPluginsKey);
  2132. if (!pFN)
  2133. goto update;
  2135. VERIFY(::lstrlen((LPCTSTR)pFN));
  2137. // 填写插件文件所在路径串
  2138. ::CopyMemory((PVOID)(lpIRWEInfo->m_Path), (CONST PVOID)pPath, 
  2139. ::lstrlen((LPCTSTR)pPath)+1); // +1 串尾0字符
  2141. // 填写插件文件名子串
  2142. ::CopyMemory((PVOID)(lpIRWEInfo->m_FileName), (CONST PVOID)pFN, 
  2143. ::lstrlen((LPCTSTR)pFN)+1); // +1 串尾0字符
  2145. // 确定插件的当前状态（现在是未调入型）
  2146. lpIRWEInfo->m_ModuleState = IRWEMS_NULL;
  2148. // 释放文件名串
  2149. ::GlobalFree(pFN); pFN = NULL;
  2151. _IRWERTF_CloseKey(hPluginsKey); hPluginsKey = NULL;
  2152. }
  2154. // 此时已无用，删之
  2155. ::GlobalFree(pPath); pPath = NULL;
  2157. // 能处理的文件类型串此时必然是空的
  2158. ASSERT(!::lstrlen((LPCTSTR)m_ProcType));
  2160. for (i=0;i<(int)dwPluginsCount;i++)
  2161. {
  2162. // 提取插件文件附加信息
  2163. lpIRWEInfo = m_EngineData.GetAt(i);
  2164. ASSERT(lpIRWEInfo);
  2166. dllpath = lpIRWEInfo->m_Path;
  2167. dllpath += lpIRWEInfo->m_FileName; // 合成文件的全路径
  2169. if (!file.Open(dllpath, CFile::modeRead|CFile::shareDenyNone))
  2170. goto update;
  2172. TRY
  2173. {
  2174. file.Seek(-(LONG)(sizeof(PLUGSIN)), SEEK_END);
  2175. // 读取插件附加信息块（在文件尾部）
  2176. file.Read(&plugsaddinfo, sizeof(PLUGSIN));
  2177. }
  2178. CATCH(CFileException, e)
  2179. {
  2180. goto update;
  2181. }
  2182. END_CATCH
  2184. file.Close();
  2186. dllpath.Empty();
  2188. VERIFY(!::memcmp((LPCTSTR)plugsaddinfo.IRWID, (LPCTSTR)"IRWP", 4));
  2190. lpIRWEInfo->m_ProcTypeNumber = plugsaddinfo.proctypenum;
  2191. ::CopyMemory((PVOID)(lpIRWEInfo->m_ProcTypeName), (CONST PVOID)plugsaddinfo.proctypestr, 32);
  2193. // 能处理的图像类型必需小于9种（最多有8种）
  2194. ASSERT(lpIRWEInfo->m_ProcTypeNumber < 9);
  2196. for (j=0;j<lpIRWEInfo->m_ProcTypeNumber;j++)
  2197. {
  2198. ::ZeroMemory((PVOID)ProcBuf, 8);
  2199. if (m_ProcCount == 0)
  2200. {
  2201. ::CopyMemory((PVOID)ProcBuf, (CONST PVOID)(lpIRWEInfo->m_ProcTypeName), 4);
  2202. }
  2203. else
  2204. {
  2205. ProcBuf[0] = ',';
  2206. ::CopyMemory((PVOID)&(ProcBuf[1]), (CONST PVOID)&(lpIRWEInfo->m_ProcTypeName[j*4]), 4);
  2207. }
  2209. ::lstrcat((LPTSTR)m_ProcType, (LPCTSTR)ProcBuf);
  2210. m_ProcID[m_ProcCount++] = lpIRWEInfo->m_SN;
  2211. }
  2213. // 引擎必需至少有一个插件支持
  2214. ASSERT((::lstrlen((LPCTSTR)m_ProcType) > 0)&&(m_ProcCount > 0));
  2216. lpIRWEInfo->m_Attrib = plugsaddinfo.attrib;
  2217. lpIRWEInfo->m_Version = plugsaddinfo.version;
  2218. lpIRWEInfo->m_Function = plugsaddinfo.function;
  2219. ::CopyMemory((PVOID)(lpIRWEInfo->m_Author), (CONST PVOID)plugsaddinfo.author, 16);
  2220. ::CopyMemory((PVOID)(lpIRWEInfo->m_EMail), (CONST PVOID)plugsaddinfo.EMail, 32);
  2221. ::CopyMemory((PVOID)(lpIRWEInfo->m_Notion), (CONST PVOID)plugsaddinfo.messages, 144);
  2222. }
  2224. ::ZeroMemory((PVOID)Active, sizeof(int)*INIT_ACTIVE_PLUGINS_NUM);
  2226. // 确定要激活哪些插件，结果存放在Active数组中
  2227. if (dwPluginsCount <= INIT_ACTIVE_PLUGINS_NUM)
  2228. {
  2229. ActiveNum = dwPluginsCount;
  2231. for (i=0;i<(int)dwPluginsCount;i++)
  2232. m_EngineData.GetAt(i)->m_SelectMark = TRUE;
  2233. }
  2234. else
  2235. {
  2236. ActiveNum = INIT_ACTIVE_PLUGINS_NUM;
  2238. // 挑选出优先级比较高的INIT_ACTIVE_PLUGINS_NUM个模块激活
  2239. for (i=0;i<INIT_ACTIVE_PLUGINS_NUM;i++)
  2240. {
  2241. for (j=0;j<(int)dwPluginsCount;j++)
  2242. {
  2243. if (m_EngineData.GetAt(j)->m_SelectMark == TRUE)
  2244. continue;
  2245. else
  2246. break;
  2247. }
  2249. ASSERT(j < (int)dwPluginsCount);
  2251. Active[i] = j;
  2252. curPRI = m_EngineData.GetAt(j)->m_PRI;
  2254. for (k=0;k<(int)dwPluginsCount;k++)
  2255. {
  2256. if (m_EngineData.GetAt(k)->m_SelectMark == TRUE)
  2257. continue;
  2258. if (curPRI > m_EngineData.GetAt(k)->m_PRI)
  2259. continue;
  2261. curPRI = m_EngineData.GetAt(k)->m_PRI;
  2262. Active[i] = k;
  2263. }
  2264. m_EngineData.GetAt(Active[i])->m_SelectMark = TRUE;
  2265. }
  2266. }
  2268. VERIFY(ActiveNum <= INIT_ACTIVE_PLUGINS_NUM);
  2270. m_EngineData.m_Active = ActiveNum;
  2272. // 激活插件
  2273. for (i=0;i<ActiveNum;i++)
  2274. {
  2275. k = Active[i];
  2276. lpIRWEInfo = m_EngineData.GetAt(k);
  2277. ASSERT(lpIRWEInfo);
  2278. ASSERT(lpIRWEInfo->m_SelectMark == TRUE);
  2280. dllpath = lpIRWEInfo->m_Path;
  2281. dllpath += lpIRWEInfo->m_FileName;
  2282. ASSERT(dllpath.GetLength());
  2284. // 填写DLL句柄
  2285. lpIRWEInfo->m_hDll = ::LoadLibrary((LPCTSTR)dllpath);
  2286. if (lpIRWEInfo->m_hDll == NULL)
  2287. goto update;
  2289. // 填写DLL接口函数地址
  2290. lpIRWEInfo->m_IRWPInterFace = (IRWP_INTERFACE)::GetProcAddress(
  2291. lpIRWEInfo->m_hDll, 
  2292. MAKEINTRESOURCE(1));
  2293. if (!lpIRWEInfo->m_IRWPInterFace)
  2294. goto update;
  2296. // 设置模块状态（IRWEMS_CR-创建但空闲）
  2297. lpIRWEInfo->m_ModuleState = IRWEMS_CR;
  2298. }
  2300. _IRWERTF_CloseKey(hKey); hKey = NULL;
  2302. // 必须有一个或一个以上的插件才能使引擎工作
  2303. ASSERT(m_EngineData.GetUsedElemSize());
  2305. return 0;
  2308. update:
  2309. if (hKey != NULL)
  2310. _IRWERTF_CloseKey(hKey);
  2311. if (hPluginsKey != NULL)
  2312. _IRWERTF_CloseKey(hPluginsKey);
  2313. if (pNames != NULL)
  2314. ::GlobalFree(pNames);
  2315. if (pPath != NULL)
  2316. ::GlobalFree(pPath);
  2317. if (pFN != NULL)
  2318. ::GlobalFree(pFN);
  2319. if (file.m_hFile != CFile::hFileNull)
  2320. file.Close();
  2322. m_EngineData.Destroy();
  2324. ActiveNum = 0;
  2325. pbyNames = NULL;
  2326. byNames = 0;
  2327. pNames = NULL;
  2328. pPath = NULL;
  2329. pFN = NULL;
  2330. lpIRWEInfo = NULL;
  2332. curPRI = 0;
  2334. iCurrent = ActiveNum = 0;
  2336. hKey = NULL; // 插件信息根句柄
  2337. hPluginsKey = NULL; // 插件句柄
  2338. dwPluginsCount = NULL; // 插件个数
  2340. if (loopcount == FALSE)
  2341. loopcount = TRUE;
  2342. else
  2343. return -1;
  2345. // 刷新系统注册表
  2346. if (_IRWE_UpdateRegTab() == -1)
  2347. return -1;
  2349. goto begin;
  2350. }
  2353. // 销毁插件信息数组
  2354. int _IRWE_DestroyPluginsInfoStock()
  2355. {
  2356. m_EngineData.Destroy();
  2358. ::ZeroMemory((PVOID)m_ProcType, IRWE_PROCTYPE_SIZE);
  2360. for (int i=0;i<IRWE_PROCID_SIZE;i++)
  2361. m_ProcID[i] = -1;
  2363. m_ProcCount = 0;
  2365. return 0;
  2366. }
  2369. // 初始化插件函数内部助手－刷新系统注册表
  2370. int _IRWE_UpdateRegTab()
  2371. {
  2372. HKEY hKey; // 引擎系统注册表句柄
  2373. HKEY hPlugKey;
  2374. LPTSTR pPath;
  2375. TCHAR m_SouPath[_MAX_PATH]; // 插件所在目录
  2376. TCHAR m_FinPath[_MAX_PATH]; // 插件搜索串(......*.irw)
  2378. // 打开插件信息句柄（系统注册表）
  2379. hKey = _IRWERTF_OpenRegTab();
  2380. if (hKey)
  2381. {
  2382. // 获取插件文件所在目录
  2383. pPath = _IRWERTF_GetPluginsPath(hKey);
  2384. if (!pPath)
  2385. {
  2386. ::GetCurrentDirectory(_MAX_PATH, (LPTSTR)m_SouPath);
  2387. if (m_SouPath[::strlen((const char*)m_SouPath)-1] != '\')
  2388. ::strcat((char*)m_SouPath, (const char*)"\");
  2389. ::strcat((char*)m_SouPath, (const char*)"IRW-PlugIn\");
  2390. }
  2391. else
  2392. {
  2393. ::strcpy((char*)m_SouPath, (const char*)pPath);
  2394. ::GlobalFree(pPath);
  2396. if (m_SouPath[::strlen((const char*)m_SouPath)-1] != '\')
  2397. ::strcat((char*)m_SouPath, (const char*)"\");
  2398. }
  2399. }
  2400. else
  2401. {
  2402. // 创建插件信息句柄
  2403. hKey = _IRWERTF_CreateRegTab();
  2404. if (!hKey)
  2405. return -1;
  2407. // 程序的IRW-PlugIn目录作为插件的缺省目录
  2408. ::GetCurrentDirectory(_MAX_PATH, (LPTSTR)m_SouPath);
  2409. if (m_SouPath[::strlen((const char*)m_SouPath)-1] != '\')
  2410. ::strcat((char*)m_SouPath, (const char*)"\");
  2411. ::strcat((char*)m_SouPath, (const char*)"IRW-PlugIn\");
  2412. }
  2414. ASSERT(hKey);
  2416. ::strcpy((char*)m_FinPath, (const char*)m_SouPath);
  2417. ::strcat((char*)m_FinPath, (const char*)"*.irw");
  2419. int i=0;
  2420. TCHAR m_SubName[256][32];
  2421. DWORD m_SubBufSize = 32;
  2422. FILETIME ft;
  2424. // 找出所有插件句柄
  2425. while(ERROR_SUCCESS == ::RegEnumKeyEx(hKey, i, (LPTSTR)(m_SubName[i]), (LPDWORD)&m_SubBufSize, NULL, NULL, NULL, &ft))
  2426. {
  2427. i++; m_SubBufSize = 32;
  2428. }
  2430. // 删之 :-)
  2431. while(i--)
  2432. ::RegDeleteKey(hKey, (LPTSTR)(m_SubName[i]));
  2435. // 搜索所有可用的插件
  2436. WIN32_FIND_DATA file;
  2437. HANDLE hFind;
  2438. int m_FineCount = 0;
  2439. TCHAR m_PlugNames[256][_MAX_PATH];
  2440. TCHAR m_FileNames[256][_MAX_PATH];
  2442. hFind = ::FindFirstFile((LPCTSTR)m_FinPath, &file);
  2443. if (INVALID_HANDLE_VALUE == hFind)
  2444. {
  2445. _IRWERTF_CloseRegTab(hKey);
  2446. return -1;
  2447. }
  2448. do
  2449. {
  2450. ::strcpy((char*)(m_PlugNames[m_FineCount]), (char*)m_SouPath);
  2451. ::strcat((char*)(m_PlugNames[m_FineCount]), (char*)(file.cFileName)); 
  2452. ::strcpy((char*)(m_FileNames[m_FineCount]), (char*)(file.cFileName)); 
  2453. m_FineCount++;
  2454. }while(::FindNextFile(hFind, &file));
  2455. ::FindClose(hFind);
  2457. CFile fp;
  2458. PLUGSIN psi;
  2459. DWORD m_RegNameCount = 0;
  2460. CString m_RegNameSpace;
  2462. m_RegNameSpace.Empty();
  2464. // 安装插件
  2465. for (i=0;i<m_FineCount;i++)
  2466. {
  2467. if (!fp.Open((LPCTSTR)m_PlugNames[i], CFile::modeRead|CFile::shareDenyNone))
  2468. {
  2469. _IRWERTF_CloseRegTab(hKey);
  2470. return -1;
  2471. }
  2473. TRY
  2474. {
  2475. fp.Seek(-(LONG)(sizeof(PLUGSIN)), CFile::end);
  2476. fp.Read((void*)&psi, sizeof(PLUGSIN));
  2477. }
  2478. CATCH(CFileException, e)
  2479. {
  2480. _IRWERTF_CloseRegTab(hKey);
  2481. fp.Close();
  2482. return -1;
  2483. }
  2484. END_CATCH
  2486. fp.Close();
  2488. if (m_RegNameCount)
  2489. m_RegNameSpace += (LPCTSTR)" ";
  2491. m_RegNameSpace += (LPCTSTR)(psi.modulename);
  2492. m_RegNameCount++;
  2494. // 创建插件句柄
  2495. hPlugKey = _IRWERTF_CreatePlugins(hKey, (LPCTSTR)(psi.modulename));
  2496. if (!hPlugKey)
  2497. {
  2498. _IRWERTF_CloseRegTab(hKey);
  2499. return -1;
  2500. }
  2502. _IRWERTF_SetPluginsFileName(hPlugKey, m_FileNames[i]);
  2503. _IRWERTF_SetPluginPRI(hPlugKey, 30); // 30为普通优先级
  2504. _IRWERTF_CloseKey(hPlugKey);
  2505. }
  2507. _IRWERTF_SetPluginNames(hKey, (LPCTSTR)m_RegNameSpace); // 设置插件名字空间:)
  2508. _IRWERTF_SetPluginsPath(hKey, (LPCTSTR)m_SouPath); // 设置插件所在路径
  2509. _IRWERTF_SetPluginNumber(hKey, m_RegNameCount); // 设置插件个数
  2511. _IRWERTF_CloseRegTab(hKey); // 关闭总句柄
  2513. return 0;
  2514. }
  2517. // 向图像读写引擎发送命令
  2518. int _IRWE_PostCommandToImgEngine(CReturnReceipt *lpCommand, BOOL pri)
  2519. {
  2520. ASSERT(lpCommand);
  2522. ::EnterCriticalSection(&m_CLCriticalSection);
  2523. if (pri == TRUE) // 优先处理的命令
  2524. m_CommandList.AddHead((void*)lpCommand);
  2525. else // 正常的命令
  2526. m_CommandList.AddTail((void*)lpCommand);
  2527. lpCommand->m_processing = IRWEPROC_FELL_IN;
  2528. ::LeaveCriticalSection(&m_CLCriticalSection);
  2530. return 0;
  2531. }
  2534. // 从总命令队列中读取命令信息
  2535. CReturnReceipt *_IRWE_ReadCommandFromTotalList()
  2536. {
  2537. CReturnReceipt *result = NULL;
  2539. ::EnterCriticalSection(&m_CLCriticalSection);
  2540. if (m_CommandList.GetCount() > 0)
  2541. {
  2542. result = (CReturnReceipt *)(m_CommandList.RemoveHead());
  2543. ASSERT(result);
  2544. result->m_processing = IRWEPROC_PROCESSING; // 表示命令开始被处理
  2545. }
  2546. ::LeaveCriticalSection(&m_CLCriticalSection);
  2548. return result;
  2549. }
  2554. //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
  2555. // 回执单实现
  2557. // 回执单申请次数的技术器初始化
  2558. UINT CReturnReceipt::m_obj_count = 0;
  2561. // 初始化回执单
  2562. CReturnReceipt::CReturnReceipt()
  2563. {
  2564. // 初始化数据包
  2565. ::ZeroMemory((PVOID)&m_data, sizeof(INFOSTR));
  2566. m_data.comm = CMD_NULL;
  2567. m_data.result = ER_EMPTY;
  2569. ::ZeroMemory((PVOID)m_data.annexdata.scAnnData, DPK_ANNEXINFOSIZE);
  2570. ::ZeroMemory((PVOID)&m_data.imginfo, sizeof(IMAGEINFOSTR));
  2571. ::ZeroMemory((PVOID)m_data.filename, DPK_FILENAMESIZE);
  2572. ::ZeroMemory((PVOID)&m_data.sDIBInfo, sizeof(INTERBITMAPINFO));
  2574. m_data.imginfo.imgtype = IMT_NULL;
  2575. m_data.imginfo.imgformat = IMF_NULL;
  2576. m_data.imginfo.compression = ICS_RGB;
  2578. m_data.pImgInfo = NULL;
  2579. m_data.pLineAddr = NULL;
  2580. m_data._pbdata = NULL;
  2581. m_data.psubimg = NULL;
  2583. m_data.state = PKST_NULL;
  2584. m_data.modify = 0;
  2585. m_data.fpProgress = fpProgress;
  2587. // 初始化回执单
  2588. m_ID = m_obj_count++; // 实例个数++
  2589. m_subproc = 0; // 数据包处理进度标志归0
  2590. m_break = FALSE; // 中断操作标志归0
  2591. m_processing = IRWEPROC_INITING; // 表明回执单处于初始化期
  2592. m_command = IRWEC_NULL;
  2593. m_modelID = -1; // 表明无插件与之对应
  2594. ::ZeroMemory((PVOID)m_filename, _MAX_PATH); // 清空文件路径缓冲区
  2595. }
  2598. // 销毁回执单
  2599. CReturnReceipt::~CReturnReceipt()
  2600. {
  2601. // 因为IRWEC_IN_END命令没有任何资源申请动作，所以略过
  2602. if (IRWEC_IN_END != m_command)
  2603. {
  2604. // 中断当前的处理作业
  2605. BreakProcess();
  2607. ASSERT(IRWEPROC_PROCESSING != m_processing);
  2609. if ((IRWEPROC_COMPLETE == m_processing)|| 
  2610. (IRWEPROC_FAIL == m_processing))
  2611. {
  2612. // 释放所有的资源
  2613. if ((LPTSTR)(m_data.pImgInfo))
  2614. ::GlobalFree(m_data.pImgInfo);
  2615. if ((LPTSTR)(m_data.pLineAddr))
  2616. ::GlobalFree(m_data.pLineAddr);
  2617. if ((LPTSTR)(m_data._pbdata))
  2618. ::GlobalFree(m_data._pbdata);
  2619. if ((LPTSTR)(m_data.psubimg))
  2620. _clear_list();
  2621. }
  2622. else
  2623. VERIFY((IRWEPROC_INITING == m_processing)||(IRWEPROC_FELL_IN == m_processing));
  2624. }
  2625. }
  2628. // 获取回执单最近执行的命令
  2629. IRWECOMMAND CReturnReceipt::GetCommand()
  2630. {
  2631. return m_command;
  2632. }
  2635. // 获取命令的执行情况的
  2636. IRWERRT_RESULT CReturnReceipt::GetResult()
  2637. {
  2638. IRWERRT_RESULT result;
  2640. switch(m_command)
  2641. {
  2642. case IRWEC_NULL: // 空命令
  2643. result = IRWERRT_SUCCESS;
  2644. break;
  2645. case IRWEC_IS_VALID_FILE_COMN: // 判断指定文件是否是指定的图像文件（普通判断）
  2646. case IRWEC_IS_VALID_FILE_NICETY: // 判断指定文件是否是指定的图像文件（精密判断）
  2647. if (m_processing == IRWEPROC_COMPLETE)
  2648. {
  2649. if (m_modelID == -1)
  2650. result = IRWERRT_FAIL;
  2651. else
  2652. result = IRWERRT_SUCCESS;// 指定的文件可以被插件处理
  2653. }
  2654. else if (m_processing == IRWEPROC_FAIL)
  2655. result = IRWERRT_FAIL;
  2656. else
  2657. result = IRWERRT_ING;
  2658. break;
  2659. case IRWEC_GET_FILE_INFO: // 获取图像文件的信息
  2660. if (m_processing == IRWEPROC_COMPLETE)
  2661. {
  2662. if (m_modelID < 0)
  2663. {
  2664. result = IRWERRT_FAIL; // 没有对应的插件支持它
  2665. break;
  2666. }
  2668. if (m_data.state == PKST_PASSINFO)
  2669. result = IRWERRT_SUCCESS;// 成功提取了图像信息
  2670. else
  2671. result = IRWERRT_FAIL;
  2672. }
  2673. else if (m_processing == IRWEPROC_FAIL)
  2674. result = IRWERRT_FAIL;
  2675. else
  2676. result = IRWERRT_ING;
  2677. break;
  2678. case IRWEC_LOAD_FROM_FILE: // 将图像文件读入内存
  2679. if (m_processing == IRWEPROC_COMPLETE)
  2680. {
  2681. if (m_modelID < 0)
  2682. {
  2683. result = IRWERRT_FAIL; // 没有对应的插件支持它，不能读取图像
  2684. break;
  2685. }
  2686. VERIFY(m_data.state == PKST_INFOANDBITS);
  2687. result = IRWERRT_SUCCESS; // 成功提取了图像信息
  2688. }
  2689. else if (m_processing == IRWEPROC_FAIL)
  2690. result = IRWERRT_FAIL;
  2691. else
  2692. result = IRWERRT_ING;
  2693. break;
  2694. case IRWEC_SAVE_TO_FILE: // 保存图像到文件
  2695. if (m_processing == IRWEPROC_COMPLETE)
  2696. {
  2697. VERIFY(m_modelID >= 0);
  2698. VERIFY(m_data.state == PKST_INFOANDBITS);
  2699. result = IRWERRT_SUCCESS; // 成功提取了图像信息
  2700. }
  2701. else if (m_processing == IRWEPROC_FAIL)
  2702. result = IRWERRT_FAIL;
  2703. else
  2704. result = IRWERRT_ING;
  2705. break;
  2706. case IRWEC_RESIZE: // 获取指定尺寸的图像
  2707. if (m_processing == IRWEPROC_COMPLETE)
  2708. {
  2709. if (m_modelID < 0)
  2710. {
  2711. result = IRWERRT_FAIL; // 没有对应的插件支持它，不能读取图像
  2712. break;
  2713. }
  2714. VERIFY(m_data.state == PKST_INFOANDBITS);
  2715. result = IRWERRT_SUCCESS; // 成功提取了图像信息
  2716. }
  2717. else if (m_processing == IRWEPROC_FAIL)
  2718. result = IRWERRT_FAIL;
  2719. else
  2720. result = IRWERRT_ING;
  2721. break;
  2722. case IRWEC_IN_END: // 结束引擎线程
  2723. if (m_processing == IRWEPROC_COMPLETE)
  2724. result = IRWERRT_SUCCESS;
  2725. else
  2726. result = IRWERRT_ING;
  2727. break;
  2728. case IRWEC_GET_THUMIMAGE: // 获取拇指图
  2729. case IRWEC_GET_THUMIMAGE_A_BIT:
  2730. if (m_processing == IRWEPROC_COMPLETE)
  2731. {
  2732. if (m_modelID < 0)
  2733. {
  2734. result = IRWERRT_FAIL; // 没有对应的插件支持它，不能读取图像
  2735. break;
  2736. }
  2737. VERIFY(this->m_thumbnails.m_thumbits);
  2738. VERIFY((m_data.state == PKST_INFOANDBITS)||(m_data.state == PKST_PASSINFO));
  2739. result = IRWERRT_SUCCESS; // 成功提取了拇指图像信息
  2740. }
  2741. else if (m_processing == IRWEPROC_FAIL)
  2742. result = IRWERRT_FAIL;
  2743. else
  2744. result = IRWERRT_ING;
  2745. break;
  2746. case IRWEC_IS_SUPPORT: // 查询指定的功能是否被支持（当前该命令未被支持）
  2747. default:
  2748. VERIFY(FALSE);
  2749. break;
  2750. }
  2751. return result;
  2752. }
  2755. // 获取最近一次操作的返回码（如果最近一次的操作失败，则
  2756. // 返回码就是失败的原因(参见IRWE_ERROR)）
  2757. IRWE_ERROR CReturnReceipt::GetLastError()
  2758. {
  2759. return m_errorinfo;
  2760. }
  2763. // 获取回执单中数据包的当前状态（参见PACKSTATE枚举定义）
  2764. PACKSTATE CReturnReceipt::GetDataPackState()
  2765. {
  2766. return m_data.state;
  2767. }
  2770. // 获取图像的宽度（0表示还未获得图像文件的相关信息）
  2771. int CReturnReceipt::GetImageWidth()
  2772. {
  2773. if (((m_data.comm == CMD_LOAD_FROM_FILE)||(m_data.comm == CMD_SAVE_TO_FILE))||
  2774. ((m_data.comm == CMD_GET_FILE_INFO)&&(m_processing == IRWEPROC_COMPLETE)))
  2775. {
  2776. // 表明图像的宽高信息已经提取出来了
  2777. // 此时，数据包必须已经获得过图像的信息，并执行成功
  2778. ASSERT(m_command >= IRWEC_GET_FILE_INFO);
  2779. // 图像的宽度不会是0
  2780. ASSERT(m_data.imginfo.width);
  2781. return (int)(m_data.imginfo.width);
  2782. }
  2783. return 0;
  2784. }
  2787. // 获取图像的高度（0表示还未获得图像文件的相关信息。高度值不会是负值）
  2788. int CReturnReceipt::GetImageHeight()
  2789. {
  2790. if (((m_data.comm == CMD_LOAD_FROM_FILE)||(m_data.comm == CMD_SAVE_TO_FILE))||
  2791. ((m_data.comm == CMD_GET_FILE_INFO)&&(m_processing == IRWEPROC_COMPLETE)))
  2792. {
  2793. // 表明图像的宽高信息已经提取出来了
  2794. // 此时，数据包必须已经获得过图像的信息，并执行成功
  2795. ASSERT(m_command >= IRWEC_GET_FILE_INFO);
  2796. // 图像的高度不会是0，也不会是负数
  2797. ASSERT(m_data.imginfo.height);
  2798. return (int)(m_data.imginfo.height);
  2799. }
  2800. return 0;
  2801. }
  2804. // 获取图像的个数（即底片与子图像的总个数，如动画GIF中图像的个数，如果
  2805. // 是静态图像，该函数将返回1，返回0表示图像文件的信息还未被读入）
  2806. int CReturnReceipt::GetImageNumber()
  2807. {
  2808. switch(m_data.comm)
  2809. {
  2810. case CMD_GET_FILE_INFO:
  2811. if (m_processing != IRWEPROC_COMPLETE)
  2812. break; // 表明正在被处理，还无法提取出数据
  2813. case CMD_LOAD_FROM_FILE:
  2814. case CMD_SAVE_TO_FILE:
  2815. // 此时，数据包必须已经获得过图像的信息，并执行成功
  2816. ASSERT(m_data.imginfo.imgnumbers);
  2817. return (int)(m_data.imginfo.imgnumbers);
  2818. default:
  2819. break;
  2820. }
  2821. return 0;
  2822. }
  2825. // 获取图像的位数据（即RGB数组的首地址，只有在读取了图像
  2826. // 之后，该函数的返回值才有意义）
  2827. LPBYTE CReturnReceipt::GetImageBitData()
  2828. {
  2829. return (LPBYTE)(m_data._pbdata);
  2830. }
  2833. // 获取图像行首地址数组地址
  2834. LPBYTE *CReturnReceipt::GetImageLineAddr()
  2835. {
  2836. return (LPBYTE*)(m_data.pLineAddr);
  2837. }
  2840. // 获取图像的信息（INTERBITMAPINFO结构的地址）
  2841. LPINTERBITMAPINFO CReturnReceipt::GetImageBitmapInfo()
  2842. {
  2843. return (LPINTERBITMAPINFO)&(m_data.sDIBInfo);
  2844. }
  2847. // 获取图像信息
  2848. LPIMAGEINFOSTR CReturnReceipt::GetImageInfo()
  2849. {
  2850. return (LPIMAGEINFOSTR)&(m_data.imginfo);
  2851. }
  2854. // 获取子图像块头元素的地址
  2855. LPSUBIMGBLOCK CReturnReceipt::GetSubImageBlock()
  2856. {
  2857. return (LPSUBIMGBLOCK)(m_data.psubimg);
  2858. }
  2861. // 获取原始图像的信息结构地址
  2862. void *CReturnReceipt::GetOrgImageInfo()
  2863. {
  2864. // 注：该参数可能会是NULL，具体情况需视具体读写模块而定
  2865. return (void*)(m_data.pImgInfo);
  2866. }
  2869. // 获取能处理本文件的图像读写插件ID号
  2870. int CReturnReceipt::GetImagePluginID()
  2871. {
  2872. // 有可能是-1，表示还没有找到对应的插件，0－n为有效ID号
  2873. return m_modelID;
  2874. }
  2877. // 获取回执单的编号（每一个回执单都有一个唯一的编号）
  2878. int CReturnReceipt::GetReturnReceiptID()
  2879. {
  2880. return m_ID;
  2881. }
  2884. // 中断当前正在处理的命令（主要是为了加快程序对用户操作的反应速度）
  2885. void CReturnReceipt::BreakProcess()
  2886. {
  2887. POSITION pos;
  2889. ::EnterCriticalSection(&m_CLCriticalSection);
  2890. ASSERT(IRWEPROC_INITING != m_processing);
  2891. if (m_processing == IRWEPROC_FELL_IN)
  2892. {
  2893. // 如果该回执单在命令队列中，还未被处理，那么将其取出
  2894. pos = m_CommandList.Find((void*)this);
  2895. ASSERT(((void*)pos) != NULL);
  2896. m_CommandList.RemoveAt(pos);
  2897. }
  2898. ::LeaveCriticalSection(&m_CLCriticalSection);
  2900. m_break = TRUE; // 设置中断操作标志
  2902. // 如果回执单正在被执行，那么等待它执行完毕
  2903. while(m_processing == IRWEPROC_PROCESSING);
  2905. m_break = FALSE; // 恢复中断操作标志
  2907. return;
  2908. }
  2911. // 获取相关联文件的路径缓冲区首地址
  2912. LPCTSTR CReturnReceipt::GetFileName()
  2913. {
  2914. return (LPCTSTR)m_filename;
  2915. }
  2918. // 删除包中的图像位数据，使之返回到INFOANDBIT之前的状态。
  2919. // 如果当前的状态已经在INFOANDBIT状态之前了，则该函数直接
  2920. // 返回。
  2921. void CReturnReceipt::ClearImageBitData()
  2922. {
  2923. switch (m_data.state)
  2924. {
  2925. case PKST_NULL: // 数据包为空
  2926. case PKST_NOTVER: // 指定文件还未通过验证的阶段（此时只有文件名变量被设置）
  2927. case PKST_PASSVER: // 指定的文件已通过验证，是有效格式的文件
  2928. // 直接返回
  2929. break;
  2930. case PKST_PASSINFO: // 已通过验证，且数据包中有该文件的相关信息
  2931. case PKST_INFOANDBITS: // 已通过验证，且有该文件的相关信息，并含有图像的位数据
  2932. {
  2933. // 等待处理作业完成
  2934. while (m_processing == IRWEPROC_PROCESSING);
  2936. // 清理已分配的内存资源
  2937. if (m_data.pImgInfo)
  2938. {
  2939. ::GlobalFree(m_data.pImgInfo);
  2940. m_data.pImgInfo = NULL;
  2941. }
  2942. if (m_data.pLineAddr)
  2943. {
  2944. ::GlobalFree(m_data.pLineAddr);
  2945. m_data.pLineAddr = NULL;
  2946. }
  2947. if (m_data._pbdata)
  2948. {
  2949. ::GlobalFree(m_data._pbdata);
  2950. m_data._pbdata = NULL;
  2951. }
  2952. if (m_data.psubimg)
  2953. {
  2954. _clear_list();
  2955. m_data.psubimg = NULL;
  2956. }
  2958. // 将回执单状态设定为PKST_PASSINFO（只包含图像信息，不包括位数据）
  2959. ::ZeroMemory((PVOID)&(m_data.sDIBInfo), sizeof(INTERBITMAPINFO));
  2961. m_data.state = PKST_PASSINFO;
  2962. m_data.modify = 0;
  2963. m_data.comm = CMD_GET_FILE_INFO;
  2964. m_data.result = ER_SUCCESS;
  2965. m_processing = IRWEPROC_COMPLETE;
  2966. m_errorinfo = IRWEERR_SUCCESS;
  2967. m_command = IRWEC_GET_FILE_INFO;
  2968. m_subproc = 100;
  2969. }
  2970. break;
  2971. case PKST_MODIFY:// 数据包中的图像已经被修改过
  2972. // 此时数据包的imginfo数据与sDIBInfo数据可能会不同，
  2973. // 所以不能简单的使用以上的办法。
  2974. // 此处强制调用者不使用这种方法。
  2975. VERIFY(FALSE);
  2976. break;
  2977. default:
  2978. VERIFY(FALSE); // 不可能存在未定义的命令，除非系统崩溃
  2979. break;
  2980. }
  2981. }
  2984. // 获取当前命令的执行进度，有五种可能的进度值，参见IRWE_PROCESSING定义
  2985. IRWE_PROCESSING CReturnReceipt::GetProcessing()
  2986. {
  2987. return m_processing;
  2988. }
  2991. // 读写模块进度控制。即读写模块回调函数。
  2992. // 入口参数1是总的进度数，参数2是当前的进度数。
  2993. // 返回参数：如果返回0，则图像读写模块继续操作，
  2994. // 如果返回非0值，则读写模块终止操作，返回。
  2995. int WINAPI CReturnReceipt::fpProgress(int tol, int cur)
  2996. {
  2997. ASSERT(m_pCurrentReturnReceipt);
  2999. m_pCurrentReturnReceipt->m_subproc = cur;
  3001. TRACE("正在处理数据包：%d，总进度：%d，当前进度：%dn", m_pCurrentReturnReceipt, tol, cur);
  3003. if (m_pCurrentReturnReceipt->m_break == TRUE)
  3004. return 1; // 中断操作
  3005. else
  3006. return 0; // 继续操作
  3007. }
  3010. // 清除子图像链表（如果图像文件中包含多幅图像，那么该链表中可能有数据）
  3011. void CReturnReceipt::_clear_list()
  3012. {
  3013. if (m_data.psubimg == NULL)
  3014. return;
  3016. if (m_data.imginfo.imgnumbers >= 1)
  3017. m_data.imginfo.imgnumbers = 1; // 如果存在子图像，那么只保留背景图
  3018. else
  3019. m_data.imginfo.imgnumbers = 0; // 如果没有图像，设0
  3021. LPSUBIMGBLOCK   lpSubImg;
  3023. while((lpSubImg=m_data.psubimg) != NULL)
  3024. {
  3025. m_data.psubimg = lpSubImg->next;
  3027. lpSubImg->number = 0; // 子图像块的序列号
  3028. lpSubImg->left = lpSubImg->top = 0; // 子图像块的显示位置（左上角）
  3029. lpSubImg->width = lpSubImg->height = 0; // 子图像块的图像宽度及高度
  3030. lpSubImg->dowith = 0; // 处置方法（针对于动画GIF）
  3031. lpSubImg->userinput = 0; // 用户输入（针对于动画GIF）
  3032. lpSubImg->colorkey = 0; // 透明色分量值
  3033. lpSubImg->time = 0; // 显示的延迟时间
  3035. if (lpSubImg->pLineAddr)
  3036. ::GlobalFree(lpSubImg->pLineAddr);
  3038. if (lpSubImg->_pbdata)
  3039. ::GlobalFree(lpSubImg->_pbdata);
  3041. lpSubImg->parents = NULL; // 第一桢图像数据的结构地址（所属数据包结构的地址）
  3042. lpSubImg->prev = NULL; // 前一桢图像数据的结构地址
  3043. lpSubImg->next = NULL; // 后一桢图像数据的结构地址（NULL表示这是最后一副图像）
  3045. ::GlobalFree(lpSubImg);
  3046. };
  3048. return;
  3049. }
  3052. // 判断回执单中是否存在拇指图（返回TRUE表示有，FALSE则没有）
  3053. // 注：返回TRUE并不意味着拇指图已经形成，本函数只能说明用于
  3054. // 存放拇指图的缓冲区已经被分配，请使用GetResult()函数判断
  3055. // 命令是否真正完成
  3056. BOOL CReturnReceipt::IsThumImage()
  3057. {
  3058. return (m_thumbnails.m_thumbits&&m_thumbnails.m_thumlines) ? TRUE:FALSE;
  3059. }
  3062. // 获取拇指图数据的来源（请参见IRWETHUM_FROM定义）
  3063. IRWETHUM_FROM CReturnReceipt::GetThumImageFrom()
  3064. {
  3065. return m_thumbnails.m_thumfrom;
  3066. }
  3069. // 获取拇指图像的尺寸数据（宽度、高度，CRect的左上角为0,0）
  3070. CRect& CReturnReceipt::GetThumImageRect()
  3071. {
  3072. static CRect rect;
  3074. rect.SetRect(0, 0, m_thumbnails.m_thuminfo.biWidth, 
  3075. m_thumbnails.m_thuminfo.biHeight);
  3077. return rect;
  3078. }
  3081. // 获取拇指图的边界正方形的宽度、高度
  3082. CRect& CReturnReceipt::GetThumBoundRect()
  3083. {
  3084. return m_thumbnails.m_thumbound;
  3085. }
  3088. // 获取拇指图的详细信息（包括拇指图的宽、高，位深等）
  3089. BITMAPINFOHEADER *CReturnReceipt::GetThumImageInfo()
  3090. {
  3091. return &(m_thumbnails.m_thuminfo);
  3092. }
  3095. // 获取拇指图的位数据
  3096. PBYTE CReturnReceipt::GetThumImageBit()
  3097. {
  3098. return (PBYTE)(m_thumbnails.m_thumbits);
  3099. }
  3103. //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
  3104. // 拇指图类实现
  3105. //
  3107. CThumImage::CThumImage()
  3108. {
  3109. m_thumfrom = IRWETHUM_FROM_NULL;
  3111. ::ZeroMemory((PVOID)&m_thuminfo, sizeof(BITMAPINFOHEADER));
  3113. m_thuminfo.biSize = sizeof(BITMAPINFOHEADER);
  3114. m_thuminfo.biBitCount = ISEE_IMAGE_BITCOUNT; // 32位
  3115. m_thuminfo.biCompression = BI_RGB;
  3116. m_thuminfo.biPlanes = 1;
  3117. m_thuminfo.biWidth = 0;
  3118. m_thuminfo.biHeight = 0;
  3120. m_thumbits = NULL;
  3121. m_thumlines= NULL;
  3123. m_thumbound.SetRectEmpty();
  3124. }
  3127. CThumImage::~CThumImage()
  3128. {
  3129. if (m_thumbits)
  3130. ::GlobalFree(m_thumbits);
  3131. if (m_thumlines)
  3132. ::GlobalFree(m_thumlines);
  3133. }
  3137. //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
  3138. // 拇指图缩放代码
  3139. // 作者：Analyst
  3141. // 初始化Alpha表
  3142. void _Thum_InitAlphaTable()
  3143. {
  3144. QWORD temp;
  3146. for(int i=0;i<_IRWE_THUM_APLHATAB_SIZE;i++)
  3147. {
  3148. temp = (QWORD)i;
  3149. s_AlphaTable[i] = temp<<48 | temp<<32 | temp<<16 | temp;
  3150. }
  3151. }
  3154. // 缩放接口函数
  3155. void _Thum_BlitStretch(DWORD **lpDesLines, int deswidth, int desheight, 
  3156. DWORD **lpSrcLines, int srcwidth, int srcheight)
  3157. {
  3158. DWORD dU = (srcwidth << 16) / deswidth;
  3159. DWORD dV = (srcheight << 16) / desheight;
  3160. DWORD V1 = 0;
  3162. for(int i = 0; i < desheight-1; i++)
  3163. {
  3164. _Thum_DrawScanLine((DWORD*)(lpDesLines[i]), (DWORD *)(lpSrcLines[(V1>>16)]), deswidth, dU);
  3165. _Thum_DrawScanLineAlpha((DWORD*)(lpDesLines[i]), (DWORD *)(lpSrcLines[(V1>>16)+1]), deswidth, dU, (V1>>9)&0x7f);
  3166. V1 += dV;
  3167. }
  3168. }
  3171. // 行缩放函数
  3172. void _Thum_DrawScanLine(DWORD* DestAddr, DWORD* SrcAddr, int Width, DWORD dU)
  3173. {
  3174. __asm{
  3175. mov esi, SrcAddr;
  3176. mov edi, DestAddr;
  3177. mov ecx, Width;
  3178. xor edx, edx;  //edx = U1
  3179. mov ebx, dU;
  3180. pxor mm7, mm7;
  3182. LoopX:
  3183. mov eax, edx;
  3184. and eax, 0xffff;
  3185. shr eax, 9;
  3186. movq mm6, [s_AlphaTable + eax * 8]; //mm6 = a2
  3187. neg eax;
  3188. add eax, 128;
  3189. movq mm5, [s_AlphaTable + eax * 8]; //mm5 = a1
  3191. mov eax, edx;
  3192. shr eax, 16;
  3193. movq mm0, [esi + eax * 4];
  3194. movq mm1, mm0;
  3195. PUNPCKLBW mm0, mm7;  //mm0 = 0a10r10g10b1
  3196. PUNPCKHBW mm1, mm7;  //mm1 = 0a20r20g20b2
  3198. pmullw mm0, mm5;
  3199. pmullw mm1, mm6;
  3200. paddw  mm0, mm1;
  3201. psrlw  mm0, 7;
  3202. packuswb mm0, mm0;
  3203. movd eax, mm0;
  3204. add edx, ebx;
  3205. stosd;
  3207. dec ecx;
  3208. jnz LoopX;
  3209. emms;
  3210. }
  3211. }
  3213. void _Thum_DrawScanLineAlpha(DWORD* DestAddr, DWORD* SrcAddr, int Width, DWORD dU, DWORD Alpha)
  3214. {
  3215. if(!Alpha)
  3216. return;
  3218. __asm{
  3219. mov esi, SrcAddr;
  3220. mov edi, DestAddr;
  3221. mov ecx, Width;
  3222. xor edx, edx;  //edx = U1
  3223. mov ebx, dU;
  3224. mov eax, Alpha;
  3225. pxor mm7, mm7;
  3226. movq mm4, [s_AlphaTable + eax * 8]; //mm4 = alpha
  3228. LoopX:
  3229. mov eax, edx;
  3230. and eax, 0xffff;
  3231. shr eax, 9;
  3232. movq mm6, [s_AlphaTable + eax * 8]; //mm6 = a2
  3233. neg eax;
  3234. add eax, 128;
  3235. movq mm5, [s_AlphaTable + eax * 8]; //mm5 = a1
  3237. mov eax, edx;
  3238. shr eax, 16;
  3239. movq mm0, [esi + eax * 4];
  3240. movq mm1, mm0;
  3241. PUNPCKLBW mm0, mm7;  //mm0 = 0a10r10g10b1
  3242. movd mm2, [edi];
  3243. PUNPCKHBW mm1, mm7;  //mm1 = 0a20r20g20b2
  3245. pmullw mm0, mm5;
  3246. punpcklbw mm2, mm7;
  3247. pmullw mm1, mm6;
  3248. paddw  mm0, mm1;
  3249. psrlw  mm0, 7;
  3251. psubw mm0, mm2;
  3252. pmullw mm0, mm4;
  3253. psraw  mm0, 7;
  3254. paddw  mm0, mm2;
  3256. packuswb mm0, mm0;
  3257. movd eax, mm0;
  3258. add edx, ebx;
  3259. stosd;
  3261. dec ecx;
  3262. jnz LoopX;
  3263. emms;
  3264. }
  3265. }