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

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

图形图象

开发平台：

Visual C++

PngModule.cpp：源码内容
  1. // PngModule.cpp : Defines the initialization routines for the DLL.
  2. //
  4. #include "stdafx.h"
  5. #include "PngModule.h"
  7. #ifdef _DEBUG
  8. #define new DEBUG_NEW
  9. #undef THIS_FILE
  10. static char THIS_FILE[] = __FILE__;
  11. #endif
  13. static char ModuleProcessImgType[]="PNG"; // 本模块能处理的图像类型
  14. static char WriterList[]="Aurora"; // 本模块的作者列表
  15. static char WriterMess[]="第一版"; // 作者留言
  17. //
  18. // Note!
  19. //
  20. // If this DLL is dynamically linked against the MFC
  21. // DLLs, any functions exported from this DLL which
  22. // call into MFC must have the AFX_MANAGE_STATE macro
  23. // added at the very beginning of the function.
  24. //
  25. // For example:
  26. //
  27. // extern "C" BOOL PASCAL EXPORT ExportedFunction()
  28. // {
  29. // AFX_MANAGE_STATE(AfxGetStaticModuleState());
  30. // // normal function body here
  31. // }
  32. //
  33. // It is very important that this macro appear in each
  34. // function, prior to any calls into MFC.  This means that
  35. // it must appear as the first statement within the 
  36. // function, even before any object variable declarations
  37. // as their constructors may generate calls into the MFC
  38. // DLL.
  39. //
  40. // Please see MFC Technical Notes 33 and 58 for additional
  41. // details.
  42. //
  44. // 在图像读写模块中，如果想分配内存，请使用API函数GlobalAlloc()
  45. // ，如果想释放内存请使用GlobalFree()函数。不要使用诸如：new
  46. // 、malloc()等函数。这是为了使各模块之间可以异地释放内存。
  47. //
  48. //
  50. /////////////////////////////////////////////////////////////////////////////
  51. // CPngModuleApp
  53. BEGIN_MESSAGE_MAP(CPngModuleApp, CWinApp)
  54. //{{AFX_MSG_MAP(CPngModuleApp)
  55. // NOTE - the ClassWizard will add and remove mapping macros here.
  56. //    DO NOT EDIT what you see in these blocks of generated code!
  57. //}}AFX_MSG_MAP
  58. END_MESSAGE_MAP()
  60. /////////////////////////////////////////////////////////////////////////////
  61. // CPngModuleApp construction
  63. CPngModuleApp::CPngModuleApp()
  64. {
  65. // TODO: add construction code here,
  66. // Place all significant initialization in InitInstance
  67. }
  69. /////////////////////////////////////////////////////////////////////////////
  70. // The one and only CPngModuleApp object
  72. CPngModuleApp theApp;
  74. long WINAPI GetLong(void)
  75. {
  76. return 2L;
  77. }
  79. // 接口函数声明 — 第一层，唯一与外界联系的接口
  80. int WINAPI AccessPNGModule(INFOSTR *pInfo)
  81. {
  82. // 这个函数可以不作修改的使用，除非你的返回值多于两种。
  84. switch(pInfo->comm)
  85. {
  86. case CMD_GETPROCTYPE: // 获取本模块能处理的图像类型
  87. _fnCMD_GETPROCTYPE(pInfo);
  88. break;
  89. case CMD_GETWRITERS: // 获取本模块的作者列表，多人时用逗号分隔
  90. _fnCMD_GETWRITERS(pInfo);
  91. break;
  92. case CMD_GETWRITERMESS: // 获取作者们的留言
  93. _fnCMD_GETWRITERMESS(pInfo);
  94. break;
  95. case CMD_GETBUILDID: // 获取图像模块内部版本号
  96. _fnCMD_GETBUILDID(pInfo);
  97. break;
  98. case CMD_IS_VALID_FILE: // 判断指定文件是否是有效的WMF文件
  99. _fnCMD_IS_VALID_FILE(pInfo);
  100. break;
  101. case CMD_GET_FILE_INFO: // 获取指定文件的信息
  102. _fnCMD_GET_FILE_INFO(pInfo);
  103. break;
  104. case CMD_LOAD_FROM_FILE: // 从指定图像文件中读取数据
  105. _fnCMD_LOAD_FROM_FILE(pInfo);
  106. break;
  107. case CMD_SAVE_TO_FILE: // 将数据保存到指定文件中
  108. _fnCMD_SAVE_TO_FILE(pInfo);
  109. break;
  110. case CMD_IS_SUPPORT: // 查询某个命令是否被支持
  111. _fnCMD_IS_SUPPORT(pInfo);
  112. break;
  113. case CMD_RESIZE: // 从新获取指定尺寸的图像位数据（只适用于矢量图像）
  114. _fnCMD_RESIZE(pInfo);
  115. break;
  116. default:
  117. pInfo->result = ER_ILLCOMM; // 非法命令
  118. ASSERT(FALSE); // 调用者的程序设计有问题 :-)
  119. break;
  120. }
  122. // 执行命令成功返回1, 失败返回0
  123. return (pInfo->result==ER_SUCCESS)? 1:0;
  124. }
  130. // 命令解释函数 — 第二层解释函数
  131. //********************************************************************//
  133. // 操作命令解释函数---解释：CMD_IS_SUPPORT命令
  134. // 查询某个命令是否被支持
  135. void _fnCMD_IS_SUPPORT(INFOSTR *pInfo)
  136. {
  137. // 这个函数是为客户程序查询时使用，如果你实现了对某个命令的
  138. // 解释，可修改相应的case中的设置，使其返回ER_SUCCESS，这就
  139. // 表示你的模块已经支持该命令了。同时，现在的这个文件中已包
  140. // 含了对前四个命令的解释，你只需向还未支持的命令函数中添加
  141. // 代码即可。
  143. ASSERT(pInfo->result == ER_EMPTY);
  145. switch(pInfo->annexdata.cmAnnData)  
  146. {
  147. case CMD_GETPROCTYPE: // 获取本模块能处理的图像类型
  148. pInfo->result = ER_SUCCESS;
  149. break;
  150. case CMD_GETWRITERS: // 获取本模块的作者列表，多人时用逗号分隔
  151. pInfo->result = ER_SUCCESS;
  152. break;
  153. case CMD_GETWRITERMESS: // 获取作者们的留言
  154. pInfo->result = ER_SUCCESS;
  155. break;
  156. case CMD_GETBUILDID: // 获取图像模块内部版本号
  157. pInfo->result = ER_SUCCESS;
  158. break;
  159. case CMD_IS_VALID_FILE: // 判断指定文件是否是有效的WMF文件
  160. pInfo->result = ER_SUCCESS;
  161. break;
  162. case CMD_GET_FILE_INFO: // 获取指定文件的信息
  163. pInfo->result = ER_SUCCESS;
  164. break;
  165. case CMD_LOAD_FROM_FILE: // 从指定图像文件中读取数据
  166. pInfo->result = ER_SUCCESS;
  167. break;
  168. case CMD_SAVE_TO_FILE: // 将数据保存到指定文件中
  169. pInfo->result = ER_SUCCESS;
  170. break;
  171. case CMD_IS_SUPPORT: // 查询某个命令是否被支持
  172. pInfo->result = ER_SUCCESS;
  173. break;
  174. case CMD_RESIZE: // 获取指定尺寸的图像（只适用于矢量图像）
  175. pInfo->result = ER_NOTSUPPORT;
  176. break;
  177. default:
  178. pInfo->result = ER_NOTSUPPORT;
  179. break;
  180. }
  181. }
  184. // 操作命令解释函数---解释：CMD_GETPROCTYPE命令
  185. // 获取本模块能处理的图像类型，如：BMP，PCX等等
  186. void _fnCMD_GETPROCTYPE(INFOSTR *pInfo)
  187. {
  188. // 这是预定义的函数代码，你可以不必修改的使用。
  190. // 根据接口定义，此时附加数据应被清空为0，所以下此断言
  191. ASSERT(pInfo->annexdata.scAnnData[0] == 0);
  192. ASSERT(pInfo->result == ER_EMPTY);
  193. // 复制能处理的类型字符串
  194. ::CopyMemory((PVOID)pInfo->annexdata.scAnnData, (PVOID)ModuleProcessImgType, 
  195. sizeof(ModuleProcessImgType));
  197. pInfo->result = ER_SUCCESS;
  198. }
  202. // 操作命令解释函数---解释：CMD_GETWRITER命令
  203. // 获取本模块的作者列表，多人时用逗号分隔
  204. void _fnCMD_GETWRITERS(INFOSTR *pInfo)
  205. {
  206. // 这是预定义的函数代码，你可以不必修改的使用。
  208. // 根据接口定义，此时附加数据应被清空为0，所以下此断言
  209. ASSERT(pInfo->annexdata.scAnnData[0] == 0);
  210. ASSERT(pInfo->result == ER_EMPTY);
  211. // 复制开发者名单串
  212. ::CopyMemory((PVOID)pInfo->annexdata.scAnnData, (PVOID)WriterList, 
  213. sizeof(WriterList));
  215. pInfo->result = ER_SUCCESS;
  216. }
  219. // 操作命令解释函数---解释：CMD_GETWRITERMESS命令
  220. // 获取作者们的留言
  221. void _fnCMD_GETWRITERMESS(INFOSTR *pInfo)
  222. {
  223. // 这是预定义的函数代码，你可以不必修改的使用。
  225. // 根据接口定义，此时附加数据应被清空为0，所以下此断言
  226. ASSERT(pInfo->annexdata.scAnnData[0] == 0);
  227. ASSERT(pInfo->result == ER_EMPTY);
  228. // 复制开发者们的留言字符串
  229. ::CopyMemory((PVOID)pInfo->annexdata.scAnnData, (PVOID)WriterMess, 
  230. sizeof(WriterMess));
  232. pInfo->result = ER_SUCCESS;
  233. }
  237. // 操作命令解释函数---解释：CMD_GETBUILDID命令
  238. // 获取图像模块内部版本号
  239. void _fnCMD_GETBUILDID(INFOSTR *pInfo)
  240. {
  241. // 这是预定义的函数代码，你可以不必修改的使用。
  243. // 根据接口定义，此时annexdata.dwAnnData应被设为0，所以下此断言
  244. ASSERT(pInfo->annexdata.dwAnnData == 0);
  245. ASSERT(pInfo->result == ER_EMPTY);
  246. // 填写内部版本号码
  247. pInfo->annexdata.dwAnnData = MODULE_BUILDID;
  249. pInfo->result = ER_SUCCESS;
  250. }
  255. // 操作命令解释函数---解释：CMD_IS_VALID_FILE命令
  256. // 判断指定文件是否是有效的WMF文件
  257. void _fnCMD_IS_VALID_FILE(INFOSTR *pInfo)
  258. {
  259. ASSERT(pInfo->result == ER_EMPTY);
  260. ASSERT(pInfo->annexdata.iAnnData == 0);
  261. ASSERT(::strlen(pInfo->filename));
  262. ASSERT(pInfo->state == PKST_NOTVER);
  264. BYTE Signature[8];
  265. HANDLE m_hPng;
  267. m_hPng = CreateFile(pInfo->filename, GENERIC_READ, FILE_SHARE_READ, NULL, 
  268. OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  270. if(m_hPng == INVALID_HANDLE_VALUE)
  271. pInfo->result = ER_COMMINFOERR; //文件打开错
  272. else
  273. {
  274. DWORD dwBytes; 
  276. //读出PNG文件头上的8个标志字节
  277. BOOL Correct = ReadFile(m_hPng, Signature, 8, &dwBytes, NULL);
  278. if(!Correct)
  279. {
  280. pInfo->result = ER_FILERWERR;
  281. TRACE("读文件错误!");
  282. CloseHandle(m_hPng);
  283. return;
  284. }
  286. pInfo->result = ER_SUCCESS;
  288. //判断是否PNG
  289. if(png_sig_cmp(Signature, 0, 8))
  290. pInfo->annexdata.iAnnData = 0;
  291. else
  292. {
  293. //合法PNG文件
  294. pInfo->annexdata.iAnnData = 1;
  295. pInfo->state = PKST_PASSVER;
  296. }
  298. CloseHandle(m_hPng);
  299. }
  301. return;
  302. }
  305. // 操作命令解释函数---解释：CMD_GET_FILE_INFO命令
  306. // 获取指定文件的信息
  307. void _fnCMD_GET_FILE_INFO(INFOSTR *pInfo)
  308. {
  309. // 检验入口参数是否符合接口定义
  310. ASSERT(pInfo->result == ER_EMPTY);
  311. ASSERT(::strlen(pInfo->filename));
  313. // 确认PNG文件有效且客户模块将imginfo晴空
  314. ASSERT(pInfo->state == PKST_PASSVER);
  315. ASSERT(pInfo->imginfo.imgtype == IMT_NULL);
  317. HANDLE m_hPng;
  318. png_structp pPng;
  319. png_infop pPngInfo;
  321. __try
  322. {
  323. m_hPng = ::CreateFile(pInfo->filename, GENERIC_READ, FILE_SHARE_READ, NULL, 
  324. OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  325. if(m_hPng == INVALID_HANDLE_VALUE) //打开文件错误
  326. {
  327. pInfo->result = ER_FILERWERR;
  328. __leave;
  329. }
  331. LPIMAGEINFOSTR lpImgInfoStr = &pInfo->imginfo;
  333. // 获取文件的长度、图像的宽度、高度等信息
  334. lpImgInfoStr->imgtype = IMT_RESSTATIC;
  335. lpImgInfoStr->imgformat = IMF_PNG;
  336. lpImgInfoStr->filesize = ::GetFileSize(m_hPng, NULL);
  338. /* 读文件信息头 */
  340. //分配PNG结构，并初始化
  341. pPng = png_create_read_struct(PNG_LIBPNG_VER_STRING, 
  342. (png_voidp)::GetForegroundWindow(), PngErrorHandler, NULL);
  343. if(pPng == NULL)
  344. {
  345. pInfo->result = ER_MEMORYERR;
  346. __leave;
  347. }
  349. //建立PNG信息头结构
  350. pPngInfo = png_create_info_struct(pPng);
  351. if(pPngInfo == NULL)
  352. {
  353. pInfo->result = ER_MEMORYERR;
  354. __leave;
  355. }
  357. //设置自定义读函数
  358. png_set_read_fn(pPng, (PVOID)m_hPng, PngRead4Win32);
  360. //读文件信息头（直到IDAT）
  361. png_read_info(pPng, pPngInfo);
  363. //获取图象信息
  364. PNGINFOHEADER pngInfoHeader;
  366. png_get_IHDR(pPng, pPngInfo, &pngInfoHeader.Width, 
  367. &pngInfoHeader.Height, &pngInfoHeader.bit_depth, 
  368. &pngInfoHeader.color_type, &pngInfoHeader.interlace_type,
  369. &pngInfoHeader.compression_type, &pngInfoHeader.filter_type);
  371. lpImgInfoStr->width = pngInfoHeader.Width;
  372. lpImgInfoStr->height = pngInfoHeader.Height;
  373. lpImgInfoStr->bitcount = 24; //所有格式的图形均转换为24位RGB
  374. lpImgInfoStr->compression = ICS_RGB;
  376. /**  获取图象每扫描行的字节数  **/
  377. /**  因为本模块准备将图形都转换为24位RGB图，所以linesize可以通过更简单的方法获得 */
  378. lpImgInfoStr->linesize = lpImgInfoStr->bitcount * lpImgInfoStr->width / 8;//png_get_rowbytes(pPng, pPngInfo);
  380. lpImgInfoStr->imgnumbers = 1; //PNG支持多幅图象，但此处暂定为1
  381. lpImgInfoStr->imgchang = 1; //图象显示器不允许修改图象
  383. //获取文件最后一次修改的时间
  384. FILETIME fLastWriteTime;
  385. SYSTEMTIME sLastWriteTime;
  386. if(::GetFileTime(m_hPng, NULL, NULL, &fLastWriteTime))
  387. {
  388. FileTimeToSystemTime(&fLastWriteTime, &sLastWriteTime);
  390. lpImgInfoStr->year = sLastWriteTime.wYear;
  391. lpImgInfoStr->monday = sLastWriteTime.wMonth;
  392. lpImgInfoStr->monday <<= 8;
  393. lpImgInfoStr->monday |= sLastWriteTime.wDay;
  395. // 获取文件最后的修改时间（字序：最高—0, 2—时，1—分，0—秒）
  396. lpImgInfoStr->time = sLastWriteTime.wHour;
  397. lpImgInfoStr->time <<= 8;
  398. lpImgInfoStr->time |= sLastWriteTime.wMinute;
  399. lpImgInfoStr->time <<= 8;
  400. lpImgInfoStr->time |= sLastWriteTime.wSecond;
  401. lpImgInfoStr->time &= 0xffffff;
  403. //读参数成功，设置state，将执行结果置为成功
  404. pInfo->state = PKST_PASSINFO;
  405. pInfo->result = ER_SUCCESS;
  407. }
  408. else
  409. pInfo->result = ER_FILERWERR;
  411. __leave;
  412. }
  413. __finally
  414. {
  415. //清除分配单元，并且关闭文件
  416. if(pPng != NULL)
  417. png_destroy_read_struct(&pPng, &pPngInfo, (png_infopp)NULL);
  419. if(m_hPng != INVALID_HANDLE_VALUE)
  420. CloseHandle(m_hPng);
  421. }
  423. return;
  424. }
  428. // 操作命令解释函数---解释：CMD_LOAD_FROM_FILE命令
  429. // 从指定图像文件中读取数据
  430. void _fnCMD_LOAD_FROM_FILE(INFOSTR *pInfo)
  431. {
  432. // 检验入口参数是否符合接口定义
  433. ASSERT(pInfo->result == ER_EMPTY);
  434. ASSERT(::strlen(pInfo->filename));
  435. // 此时，该文件必需是一个已存在的、有效的WMF文件，并且数据包中
  436. // 含有该文件的信息（imginfo结构中）
  437. ASSERT(pInfo->state == PKST_PASSINFO);
  438. ASSERT(pInfo->imginfo.imgformat == IMF_PNG);
  439. ASSERT(pInfo->pImgInfo == NULL);
  440. // 必需设置标准图像格式信息
  441. ASSERT(pInfo->sDIBInfo.bmi.biSize == sizeof(BITMAPINFOHEADER));
  442. ASSERT(pInfo->pLineAddr != NULL);
  443. ASSERT(pInfo->_pbdata != NULL);
  445. HANDLE hPng;
  446. png_structp pPng;
  447. png_infop pPngInfo;
  449. __try
  450. {
  451. //分配PNG结构，并初始化
  452. pPng = png_create_read_struct(PNG_LIBPNG_VER_STRING, 
  453. (png_voidp)::GetForegroundWindow(), PngErrorHandler, NULL);
  454. if(pPng == NULL)
  455. {
  456. pInfo->result = ER_MEMORYERR;
  457. __leave;
  458. }
  460. //建立PNG信息头结构
  461. pPngInfo = png_create_info_struct(pPng);
  462. if(pPngInfo == NULL)
  463. {
  464. pInfo->result = ER_MEMORYERR;
  465. __leave;
  466. }
  468. hPng = ::CreateFile(pInfo->filename, GENERIC_READ, FILE_SHARE_READ, NULL, 
  469. OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  470. if(hPng == INVALID_HANDLE_VALUE) //打开文件错误
  471. {
  472. pInfo->result = ER_FILERWERR;
  473. __leave;
  474. }
  476. //设置自定义读函数
  477. png_set_read_fn(pPng, (PVOID)hPng, PngRead4Win32);
  479.     if (setjmp(png_jmpbuf(pPng)))
  480.     {
  481. pInfo->result = ER_FILERWERR;
  482. __leave;
  483. }
  485. //读文件信息头（直到IDAT），在读取图象数据前必须
  486. png_read_info(pPng, pPngInfo);
  488. //获取PNG图象头，以备设置读取变换时引用
  489. PNGINFOHEADER pngInfoHeader;
  490. png_get_IHDR(pPng, pPngInfo, &pngInfoHeader.Width, 
  491. &pngInfoHeader.Height, &pngInfoHeader.bit_depth, 
  492. &pngInfoHeader.color_type, &pngInfoHeader.interlace_type,
  493. &pngInfoHeader.compression_type, &pngInfoHeader.filter_type);
  495. /* 通知PNGLIB将16位图形削减为8位 */
  496. png_set_strip_16(pPng);
  498. /* 将1、2、4位图形由压缩状态变为每位象素用1字节表示 */
  499. png_set_packing(pPng);
  501. /* 将索引图转换为RGB图 */
  502. if (pngInfoHeader.color_type == PNG_COLOR_TYPE_PALETTE &&
  503. pngInfoHeader.bit_depth <= 8)
  504. png_set_palette_to_rgb(pPng);
  506. /* 将小于8位的灰度图转换为8位灰度 */
  507. if (pngInfoHeader.color_type == PNG_COLOR_TYPE_GRAY && 
  508. pngInfoHeader.bit_depth < 8)
  509. png_set_gray_1_2_4_to_8(pPng);
  511. /* 将tRNS通道转换为alpha通道 */
  512. if (png_get_valid(pPng, pPngInfo,PNG_INFO_tRNS)) 
  513. png_set_tRNS_to_alpha(pPng);
  516. /* 若读图象时使用png_set_strip_alpha()去掉alpha通道，则可以不设置背景色
  517.    * 若读图象时未去掉alpha通道，则必须设置背景色，否则不能正确显示
  518.  */
  519. png_color_16 *image_background;
  520. png_color_16 user_background; //使用当前背景做图形背景
  521. COLORREF bkColor = ::GetBkColor(::GetDC(::GetForegroundWindow()));
  522. user_background.index = 0;
  523. user_background.red = GetRValue(bkColor);
  524. user_background.blue = GetBValue(bkColor);
  525. user_background.green = GetGValue(bkColor);
  526. user_background.gray = 255;
  528. if (png_get_bKGD(pPng, pPngInfo, &image_background)) //图象自带背景
  529. png_set_background(pPng, image_background,
  530.  PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
  531. else 
  532. png_set_background(pPng, &user_background, PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
  535. /* 调整屏幕显示的GAMMA值 */
  536. /* screen gamma由CRT_gamma和环境矫正gamma组成 */
  538. /* 暂时不实现用户指定屏幕gamma */
  539. double screen_gamma;
  540. char *gamma_str;
  541. if ((gamma_str = getenv("SCREEN_GAMMA")) != NULL) //获取当前环境变量的值
  542. {
  543. screen_gamma = atof(gamma_str);
  544. }
  545. else
  546. {
  547. screen_gamma = 2.2;  /* A good guess for a PC monitors in a dimly
  548.   lit room */
  549. }
  551. /* 让LIBPNG处理gamma矫正 */
  552. /* 此处应支持用户输入图象gamma值 */
  553. int intent;
  555. if (png_get_sRGB(pPng, pPngInfo, &intent))
  556. png_set_gamma(pPng, screen_gamma, 0.45455); /* 对图象gamma的猜测 */
  557. else
  558. {
  559. double image_gamma;
  560. if (png_get_gAMA(pPng, pPngInfo, &image_gamma))
  561. png_set_gamma(pPng, screen_gamma, image_gamma);
  562. else
  563.  png_set_gamma(pPng, screen_gamma, 0.45455);
  564. }
  566. /* 将图象数据由RGB转换为BGR */
  567. png_set_bgr(pPng);
  569. /* 将灰度图转换为RGB图 */
  570. if (pngInfoHeader.color_type == PNG_COLOR_TYPE_GRAY || 
  571. pngInfoHeader.color_type == PNG_COLOR_TYPE_GRAY_ALPHA)          
  572. png_set_gray_to_rgb(pPng);
  574. /* 打开INTERLACE处理器(使用png_read_row读图象时必须) */
  575. pngInfoHeader.number_passes = png_set_interlace_handling(pPng);
  577. /* 调用上述变换函数后必须，更新信息结构 */
  578. png_read_update_info(pPng, pPngInfo);
  581. // 下面开始读图象数据
  582. // 存储单元以在客户模块中分配
  583. DWORD Height = (pInfo->imginfo).height;
  584. DWORD dwBytes = (pInfo->imginfo).linesize;
  586. //分配读文件所需的数据缓冲区及行指针（必须）
  587. png_bytep* row_pointers = (png_bytep*)new PBYTE[Height];
  588. if(row_pointers == NULL)
  589. {
  590. pInfo->result = ER_MEMORYERR;
  591. __leave;
  592. }
  594. PBYTE pImage = new BYTE[Height * dwBytes];
  595. if(pImage == NULL)
  596. {
  597. delete []row_pointers;
  598. pInfo->result = ER_MEMORYERR;
  599. __leave;
  600. }
  602. //按24位位深度设置行指针，以正确读取图象数据
  603. for(DWORD row = 0; row < Height; row ++)
  604. row_pointers[row] = (png_bytep)(pImage + row * dwBytes);
  606. //设置JUMPBUFFER以便PNGLIB在遇到错误时能返回这里处理错误
  607. if (setjmp(png_jmpbuf(pPng)))
  608. {
  609. pInfo->result = ER_FILERWERR;
  610. __leave;
  611. }
  613. int pass;
  614. for(pass = 0; pass < pngInfoHeader.number_passes; pass++)
  615. {
  616. //每次读取一行图象
  617. for (row = 0L; row < Height; row++)
  618. {
  619. //调用回调函数，处理用户中断请求
  620. //这里的效果可能不太好，因为要在处理完一行数据之后才响应用户请求
  621. if(pInfo->fpProgress)
  622. {
  623. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, (100 * row * (pass + 1))/
  624. (Height * pngInfoHeader.number_passes)))
  625. { // 如果进度函数返回1，则说明用户想中断操作，返回。
  626. pInfo->result = ER_USERBREAK;
  627. __leave;
  628. }
  629. }
  631. //从文件中读取一行数据
  632. png_read_rows(pPng, &row_pointers[row], NULL, 1);
  633. }
  634. }
  636. //读取图象附加信息，包括zTxt、sTxt、tIME通道的信息
  637. //对这些信息暂不处理，以后可以加到pImginfo中传递给客户模块
  638. png_read_end(pPng, pPngInfo);
  640. //根据pInfo->sDIBInfo.bmi中提供的标准图象信息转换图象格式
  641. ASSERT(pInfo->sDIBInfo.bmi.biPlanes == 1);
  642. // 可接收三中格式的图像位数据请求：16,24,32。并且要求数据包位
  643. ASSERT((pInfo->sDIBInfo.bmi.biBitCount==16)||(pInfo->sDIBInfo.bmi.biBitCount==24)||(pInfo->sDIBInfo.bmi.biBitCount==32));
  644. if(pInfo->sDIBInfo.bmi.biBitCount == 16)
  645. {
  646. if(!Image24to16(pInfo, pImage, row_pointers))
  647. {
  648. //操作失败，释放内存
  649.   delete []pImage;
  650. delete []row_pointers;
  651. __leave;
  652. }
  653. }
  654. else if(pInfo->sDIBInfo.bmi.biBitCount == 32)
  655. {
  656. if(!Image24to32(pInfo, pImage, row_pointers))
  657. {
  658. delete []pImage;
  659. delete []row_pointers;
  660. __leave;
  661. }
  662. }
  663. else
  664. {
  665. //24位倒置、对齐并且拷贝到图象缓冲区中
  666. if(!Image24to24(pInfo, pImage, row_pointers))
  667. {
  668. delete []pImage;
  669. delete []row_pointers;
  670. __leave;
  671. }
  672. }
  674. //释放图象缓冲区
  675. delete []row_pointers;
  676. delete []pImage;
  678.  //成功!
  679.  pInfo->state = PKST_INFOANDBITS;
  680.  pInfo->result = ER_SUCCESS;
  682.  __leave;
  683. }
  684. __finally
  685. {
  686. //关闭PNG文件
  687. if(hPng != INVALID_HANDLE_VALUE)
  688. CloseHandle(hPng);
  690. //清除分配单元
  691. if(pPng != NULL)
  692. png_destroy_read_struct(&pPng, &pPngInfo, (png_infopp)NULL);
  693. }
  695. return;
  696. }
  700. // 操作命令解释函数---解释：CMD_SAVE_TO_FILE命令
  701. // 将数据保存到指定文件中
  702. void _fnCMD_SAVE_TO_FILE(INFOSTR *pInfo)
  703. {
  704. // 检验入口参数是否符合接口定义
  705. ASSERT(pInfo->result == ER_EMPTY);
  706. ASSERT(::strlen(pInfo->filename));
  707. // 此时，该文件必需是一个已存在的、有效的WMF文件，并且数据包中
  708. // 含有该文件的信息（imginfo结构中）
  709. ASSERT(pInfo->state == PKST_INFOANDBITS);
  711. // 必须存在有效的图象信息
  712. ASSERT(pInfo->sDIBInfo.bmi.biSize == sizeof(BITMAPINFOHEADER));
  713. ASSERT(pInfo->pLineAddr != NULL);
  714. ASSERT(pInfo->_pbdata != NULL);
  716. //仅支持16、24、32位位图
  717. if(pInfo->sDIBInfo.bmi.biBitCount == 1 || pInfo->sDIBInfo.bmi.biBitCount == 4 ||
  718. pInfo->sDIBInfo.bmi.biBitCount == 8)
  719. {
  720. pInfo->result = ER_NOTSUPPORT;
  721. return;
  722. }
  724. HANDLE hPng;
  725. png_structp pPng;
  726. png_infop pPngInfo;
  728. __try
  729. {
  730. //分配PNG结构，并初始化
  731. pPng = png_create_write_struct(PNG_LIBPNG_VER_STRING, 
  732. (png_voidp)::GetForegroundWindow(), PngErrorHandler, NULL);
  733. if(pPng == NULL)
  734. {
  735. pInfo->result = ER_MEMORYERR;
  736. __leave;
  737. }
  739. //建立PNG信息头结构
  740. pPngInfo = png_create_info_struct(pPng);
  741. if(pPngInfo == NULL)
  742. {
  743. pInfo->result = ER_MEMORYERR;
  744. __leave;
  745. }
  747. hPng = ::CreateFile(pInfo->filename, GENERIC_READ | GENERIC_WRITE, 
  748. FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  749. if(hPng == INVALID_HANDLE_VALUE) //打开文件错误
  750. {
  751. pInfo->result = ER_FILERWERR;
  752. __leave;
  753. }
  755. //设置自定义写函数
  756. png_set_write_fn(pPng, (PVOID)hPng, PngWrite4Win32, (png_flush_ptr)PngFlush4Win32);
  758.     if (setjmp(png_jmpbuf(pPng)))
  759.     {
  760. pInfo->result = ER_FILERWERR;
  761. __leave;
  762. }
  764. //设置并写文件信息头
  765. pngSetIHDR(pPng, pPngInfo, pInfo);
  767. //图象变换
  768. BITMAPINFOHEADER bmpInfo = pInfo->sDIBInfo.bmi;
  769. DWORD BitCount = bmpInfo.biBitCount;
  770. DWORD Height = bmpInfo.biHeight;
  771. DWORD Width = bmpInfo.biWidth;
  773. PBYTE pngImage;
  774. PBYTE* row_pointers;
  776. pngImage = new BYTE[Height * Width * 3];
  777. if(pngImage == NULL)
  778. {
  779. pInfo->result = ER_MEMORYERR;
  780. __leave;
  781. }
  783. row_pointers = new PBYTE[Height];
  784. if(row_pointers == NULL)
  785. {
  786. pInfo->result = ER_MEMORYERR;
  787. __leave;
  788. }
  790. if(BitCount == 16)
  791. {
  792. if(!TransformImage16(pInfo, pngImage))
  793. {
  794. delete []pngImage;
  795. delete []row_pointers;
  796. __leave;
  797. }
  799. //置行指针，行指针倒置，因为PNG图象是top-down排列的
  800. for(DWORD i = 0; i < Height; i++)
  801. row_pointers[i] = pngImage + Width * 3 * (Height - i - 1);
  802. }
  803. else if(BitCount == 24)
  804. {
  805. if(!TransformImage24(pInfo, pngImage))
  806. {
  807. delete []pngImage;
  808. delete []row_pointers;
  809. __leave;
  810. }
  812. for(DWORD i = 0; i < Height; i++)
  813. row_pointers[i] = pngImage + Width * 3 * (Height - i - 1);
  814. }
  815. else //if(BitCount == 32)
  816. {
  817. if(!TransformImage32(pInfo, pngImage))
  818. {
  819. delete []pngImage;
  820. delete []row_pointers;
  821. __leave;
  822. }
  824. for(DWORD i = 0; i < Height; i++)
  825. row_pointers[i] = pngImage + Width * 3 * (Height - i - 1);
  826. }
  828. //写图象
  829. /* 这里用交错格式（interlaced）存储 */
  830. DWORD number_passes = png_set_interlace_handling(pPng);
  832.     for (DWORD pass = 0; pass < number_passes; pass++)
  833. { 
  834. /* 一次只写入一行 */
  835.     for (DWORD y = 0; y < Height; y++)
  836. { 
  837. //进度函数调用
  838. if(pInfo->fpProgress)
  839. {
  840. if ((*(pInfo->fpProgress))(RWPROGRESSSIZE, pass * y * 100 / (pass * Height)))
  841. {
  842. pInfo->result = ER_USERBREAK;
  843. __leave;
  844. }
  845. } 
  847. png_write_rows(pPng, &row_pointers[y], 1);
  848. } 
  849. } 
  851.     /* 这里可以写入tEXt, zTXt, and tIME */
  853. /* 写入IEND通道，必须 */
  854. png_write_end(pPng, pPngInfo);
  856. delete []pngImage;
  857. delete []row_pointers;
  859. /* 使用png_free释放用png_malloced分配的调色板或其他单元 */
  860. //png_free(pPng, palette);
  862. pInfo->result = ER_SUCCESS;
  863. }
  864. __finally
  865. {
  866. //关闭PNG文件
  867. if(hPng != INVALID_HANDLE_VALUE)
  868. CloseHandle(hPng);
  870. //清除分配单元
  871. if(pPng != NULL)
  872. png_destroy_write_struct(&pPng, &pPngInfo);
  873. }
  875. return;
  876. }
  879. // 操作命令解释函数---解释：CMD_RESIZE命令
  880. // 重新获取指定尺寸的图像位数据（只适用于矢量图像）
  881. void _fnCMD_RESIZE(INFOSTR *pInfo)
  882. {
  883. pInfo->result = ER_NOTSUPPORT;
  884. return;
  885. }
  889. /* ====================================================================================== */
  890. /* 内部处理函数   */
  891. /* ====================================================================================== */
  894. /*
  895.  * PNG库自定义错误处理函数
  896.  * 
  897.  */
  898. static void
  899. PngErrorHandler(png_structp png_ptr, png_const_charp message)
  900. {
  901. TRACE("错误:%s", message);
  902. CString ErrMsg = "错误:";
  903. ErrMsg += message; 
  905. ::MessageBox((HWND)png_ptr->error_ptr, ErrMsg, NULL, 0);
  907. #ifdef PNG_SETJMP_SUPPORTED
  908. #  ifdef USE_FAR_KEYWORD
  909.    {
  910.       jmp_buf jmpbuf;
  911.       png_memcpy(jmpbuf,png_ptr->jmpbuf,sizeof(jmp_buf));
  912.       longjmp(jmpbuf, 1);
  913.    }
  914. #  else
  915.    longjmp(png_ptr->jmpbuf, 1);
  916. # endif
  917. #else
  918.    if (png_ptr == NULL)
  919.      /* make compiler happy */ ;
  920.    PNG_ABORT();
  921. #endif
  922. }
  924. /* ==============================
  925.  * PNG库自定义读函数
  926.  * 参数：
  927.  * data — 返回数据缓冲区
  928.  * length — 读数据长度
  929.  */
  930. static void
  931. PngRead4Win32(png_structp png_ptr, png_bytep data, png_size_t length)
  932. {
  933.    HANDLE m_hPng;
  935.    m_hPng = (HANDLE)CVT_PTR(png_ptr->io_ptr);
  937.    if(m_hPng != NULL)
  938.    {
  939.    DWORD dwBytes;
  940.    BOOL Correct = ReadFile(m_hPng, (PVOID)data, (DWORD)length, &dwBytes, NULL);
  941.    if(!Correct || dwBytes != (DWORD)length)
  942.    {
  943.    png_error(png_ptr, "Read Error");
  944.    }
  945.    }
  946. }
  949. /* ==============================
  950.  * PNG库自定义写函数
  951.  * 参数：
  952.  * data — 数据缓冲区
  953.  * length — 数据长度
  954.  */
  955. static void
  956. PngWrite4Win32(png_structp png_ptr, png_bytep data, png_size_t length)
  957. {
  958.    HANDLE m_hPng;
  960.    m_hPng = (HANDLE)CVT_PTR(png_ptr->io_ptr);
  962.    if(m_hPng != NULL)
  963.    {
  964.    DWORD dwBytes;
  965.    BOOL Correct = WriteFile(m_hPng, (PVOID)data, (DWORD)length, &dwBytes, NULL);
  966.    if(!Correct || dwBytes != (DWORD)length)
  967.    {
  968.    png_error(png_ptr, "Write Error");
  969.    }
  970.    }
  971. }
  974. /* ==============================
  975.  * PNG库自定义FLUSH函数
  976.  * 参数：
  977.  * data — 数据缓冲区
  978.  * length — 数据长度
  979.  */
  980. static void
  981. PngFlush4Win32(png_structp png_ptr)
  982. {
  983.    HANDLE m_hPng;
  985.    m_hPng = (HANDLE)CVT_PTR(png_ptr->io_ptr);
  987.    if (m_hPng != NULL)
  988.    {
  989.    BOOL Correct = FlushFileBuffers(m_hPng);
  990.    if(!Correct)
  991.        png_error(png_ptr, "Flush Error");
  992.    }
  993. }
  996. /* ==========================================================================*
  997.  * 图象的输出格式将根据用户的需要进行适当的变换
  998.  * 下面的一组函数用于将图象由从PNG读出时的24位变换为输出格式
  999.  * ==========================================================================*/
  1001. /* 
  1002.  * 将图象由24位转换为32位
  1003.  */
  1004. BOOL Image24to32(INFOSTR *pInfo, PBYTE pImage, PBYTE* pLineAddr)
  1005. {
  1006. DWORD Height = (pInfo->imginfo).height;
  1007. DWORD Width = (pInfo->imginfo).width;
  1009. PBYTE p2 = pInfo->_pbdata;
  1010. PBYTE p1;// = pImage;
  1011. PBYTE *pLine = pLineAddr + Height - 1;
  1013. for(DWORD y = 0L; y < Height; y++)
  1014. {
  1015. if(pInfo->fpProgress)
  1016. {
  1017. if ((*(pInfo->fpProgress))(RWPROGRESSSIZE, y * 100 / Height))
  1018. {
  1019. pInfo->result = ER_USERBREAK;
  1020. return FALSE;
  1021. }
  1022. }
  1024. p1 = *(pLine --);
  1025. for(DWORD i = 0L; i < Width; i ++)
  1026. {
  1027. *p2++ = *p1++;
  1028. *p2++ = *p1++;
  1029. *p2++ = *p1++;
  1030. *p2++ = 0;
  1031. }
  1032. }
  1034. return TRUE;
  1035. }
  1038. /*
  1039.  * 将位图转换为16位
  1040.  */
  1041. BOOL Image24to16(INFOSTR *pInfo, PBYTE pImage, PBYTE* pLineAddr)
  1042. {
  1043. DWORD BMask = (pInfo->sDIBInfo).bmask;
  1044. DWORD RMask = (pInfo->sDIBInfo).rmask;
  1045. DWORD GMask = (pInfo->sDIBInfo).gmask;
  1047. DWORD Height = (pInfo->imginfo).height;
  1048. DWORD Width = (pInfo->imginfo).width;
  1050. if(pInfo->sDIBInfo.bmi.biCompression == BI_RGB)
  1051. {
  1052. BMask = 0x0000001F;
  1053. GMask = 0x000003E0;
  1054. RMask = 0x00007C00; 
  1055. }
  1057. PWORD p2 = (PWORD)pInfo->_pbdata;
  1058. PBYTE p1;// = pImage;
  1059. PBYTE *pLine = pLineAddr + Height - 1;
  1060. WORD Red, Blue, Green;
  1061. WORD rs;
  1062. double Rmax24, Bmax24, Gmax24;
  1063. double Rmax16, Bmax16, Gmax16;
  1065. Rmax24 = Bmax24 = Gmax24 = (1 << 8) - 1;
  1066. Rmax16 = Bmax16 = (1 << 5) - 1;
  1068. if(GMask == 0x000003E0)
  1069. {
  1070. Gmax16 = (1 << 5) - 1;
  1071. rs = 10;
  1072. }
  1073. else
  1074. {
  1075. rs = 11;
  1076. Gmax16 = (1 << 6) - 1;
  1077. }
  1079. for(DWORD y = 0L; y < Height; y++)
  1080. {
  1081. if(pInfo->fpProgress)
  1082. {
  1083. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, y * 100 / Height))
  1084. {
  1085. pInfo->result = ER_USERBREAK;
  1086. return FALSE;
  1087. }
  1088. }
  1090. p1 = *(pLine --);
  1091. for(DWORD i = 0; i < Width; i++)
  1092. {
  1093. //为保持与原图基本一致应按比例变化
  1094. Blue = (WORD)((double)(*p1++) * Bmax16 / Bmax24) & BMask;
  1095. Green = ((WORD)((double)(*p1++) * Gmax16 / Gmax24) << 5) & GMask;
  1096. Red = ((WORD)((double)(*p1++) * Rmax16 / Rmax24) << rs) & RMask;
  1097. *p2++ = Blue | Green | Red;
  1098. }
  1099. //考虑DWORD对齐
  1100. if(Width % 2)
  1101. *p2++  = 255; //边界用白色填充
  1102. }
  1104. return TRUE;
  1105. }
  1108. /*
  1109.  * 24位位图倒置，并且按DWORD边界对齐
  1110.  */
  1111. BOOL Image24to24(INFOSTR *pInfo, PBYTE pImage, PBYTE* pLineAddr)
  1112. {
  1113. DWORD Height = (pInfo->imginfo).height;
  1114. DWORD Width = (pInfo->imginfo).width * 3;
  1115. DWORD Linesize = (Width + sizeof(DWORD) - 1) / sizeof(DWORD) * sizeof(DWORD);
  1117. PBYTE p1;
  1118. PBYTE p2 = pInfo->_pbdata;
  1119. PBYTE *pLine = pLineAddr + Height - 1;
  1121. for(DWORD y = 0L; y < Height; y++)
  1122. {
  1123. if(pInfo->fpProgress)
  1124. {
  1125. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, y * 100 / Height))
  1126. {
  1127. pInfo->result = ER_USERBREAK;
  1128. return FALSE;
  1129. }
  1130. }
  1132. p1 = *(pLine--);
  1133. memcpy(p2, p1, Width);
  1135. //DWORD对齐
  1136. memset(p2 + Width, 255, Linesize - Width);
  1137. p2 += Linesize;
  1138. }
  1140. return TRUE;
  1141. }
  1144. /* ===============================================================================*
  1145.  * 设置PNG头信息，并且写PNG文件头
  1146.  * ===============================================================================*/
  1148. /*
  1149.  * 根据BMP信息头设置PNG文件信息头
  1150.  */
  1151. void pngSetIHDR(png_structp pPng, png_infop pPngInfo, INFOSTR *pInfo)
  1152. {
  1153. //所有的PNG文件都保存为color type 2, bitdepth 8(24位), 无alpha通道的图形
  1154. DWORD Height, Width;
  1155. int color_type, bit_depth;
  1156. int compression_type, filter_type;
  1157. int interlace_type = PNG_INTERLACE_ADAM7; //缺省设置为ADAM7交错图象
  1159. compression_type = PNG_COMPRESSION_TYPE_DEFAULT; //缺省压缩类型
  1160. filter_type = PNG_FILTER_TYPE_DEFAULT; //缺省FILTER
  1162. BITMAPINFOHEADER bmpInfo = pInfo->sDIBInfo.bmi;
  1164. Height = bmpInfo.biHeight; //图象真实高度
  1165. Width = bmpInfo.biWidth; //图象真实宽度
  1167. int BitCount = bmpInfo.biBitCount;
  1169. color_type = 2; //RGB图
  1170. bit_depth = 8;
  1172. png_set_IHDR(pPng, pPngInfo, Width, Height, bit_depth, color_type,
  1173. interlace_type, compression_type, filter_type);
  1175. if(BitCount == 16)
  1176. {
  1177. //设置真实位数通道
  1178. png_color_8 sig_bit;
  1180. sig_bit.red = 5;
  1181. sig_bit.blue = 5;
  1182. sig_bit.green = 5;
  1183. if(bmpInfo.biCompression == BI_BITFIELDS)
  1184. if(pInfo->sDIBInfo.gmask == 0x07E0)
  1185. sig_bit.green = 6;
  1187. png_set_sBIT(pPng, pPngInfo, &sig_bit);
  1188. }
  1190. //将信息写入信息头
  1191. png_write_info(pPng, pPngInfo);
  1192. }
  1195. /* ============================================================================*
  1196.  * 调用PNGLIB存储图象之前先将图象数据转换为PNG格式的数据
  1197.  * 下面的几个函数用于将图象由BMP格式转换为PNG格式
  1198.  * ============================================================================*/
  1200. /*
  1201.  * 图象变换，将16位图象扩展为24位，并按BGR格式排列
  1202.  */
  1203. BOOL TransformImage16(INFOSTR *pInfo, PBYTE pngImage)
  1204. {
  1205. PBYTE pImage = (PBYTE)pInfo->_pbdata;
  1206. BITMAPINFOHEADER bmpInfo = pInfo->sDIBInfo.bmi;
  1208. ASSERT(bmpInfo.biBitCount == 16);
  1210. DWORD gMask, bMask, rMask;
  1212. bMask = 0x001F;
  1213. gMask = 0x03E0;
  1214. rMask = 0x7C00;
  1216. if(bmpInfo.biCompression == BI_BITFIELDS)
  1217. {
  1218. bMask = pInfo->sDIBInfo.bmask;
  1219. gMask = pInfo->sDIBInfo.gmask;
  1220. rMask = pInfo->sDIBInfo.rmask;
  1221. }
  1223. int rs = 10;
  1224. DWORD Rmax16, Gmax16, Bmax16;
  1225. DWORD Rmax24, Gmax24, Bmax24;
  1227. Rmax16 = Gmax16 = Bmax16 = (1 << 5) - 1;
  1228. Rmax24 = Gmax24 = Bmax24 = (1 << 8) - 1;
  1230. if(gMask == 0x07e0)
  1231. {
  1232. rs = 10;
  1233. Gmax16 = (1 << 6) - 1;
  1234. }
  1236. DWORD height = bmpInfo.biHeight;
  1237. DWORD width = bmpInfo.biWidth;
  1238. DWORD linesize = DIBSCANLINE_WIDTHBYTES(width * bmpInfo.biBitCount);
  1240. PWORD pRow = (PWORD)pImage;
  1241. PBYTE p = pngImage;
  1242. for(DWORD row = 0; row < height; row ++)
  1243. {
  1244. pRow = (WORD*)(pImage + linesize * row);
  1245. //进度控制
  1246. if(pInfo->fpProgress)
  1247. {
  1248. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, row * 100 / height))
  1249. {
  1250. pInfo->result = ER_USERBREAK;
  1251. return FALSE;
  1252. }
  1253. }
  1255. for(DWORD i = 0; i < width; i++)
  1256. {
  1257. WORD red = (*pRow) & rMask;
  1258. WORD green = *pRow & gMask;
  1260. *p++ = (BYTE)((double)(red >> rs) * (double)Rmax24 / (double)Rmax16); //red
  1261. *p++ = (BYTE)((double)(green >> 5) * (double)Gmax24 / (double)Gmax16); //green
  1262. *p++ = (BYTE)((double)(*pRow & bMask) * (double)Bmax24 / (double)Bmax16);//blue
  1264. pRow ++;
  1265. }
  1266. }
  1268. return TRUE;
  1269. }
  1272. /*
  1273.  * 24位图象变换，24位图象可以不用变换，直接拷贝图象即可。
  1274.  *
  1275.  * 这里去掉为DWORD对齐而增加的填充字节。
  1276.  *
  1277.  */
  1278. BOOL TransformImage24(INFOSTR *pInfo, PBYTE pngImage)
  1279. {
  1280. PBYTE pImage = (PBYTE)pInfo->_pbdata;
  1281. BITMAPINFOHEADER bmpInfo = pInfo->sDIBInfo.bmi;
  1283. ASSERT(bmpInfo.biBitCount == 24);
  1285. DWORD height = bmpInfo.biHeight;
  1286. DWORD width = bmpInfo.biWidth;
  1287. DWORD linesize = DIBSCANLINE_WIDTHBYTES(width * bmpInfo.biBitCount);
  1289. PBYTE pRow = pImage;
  1290. PBYTE p = pngImage;
  1291. for(DWORD row = 0; row < height; row ++)
  1292. {
  1293. pRow = pImage + row * linesize;
  1295. //进度控制
  1296. if(pInfo->fpProgress)
  1297. {
  1298. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, row * 100 / height))
  1299. {
  1300. pInfo->result = ER_USERBREAK;
  1301. return FALSE;
  1302. }
  1303. }
  1305. for(DWORD i = 0; i < width; i++)
  1306. {
  1307. *p++ = *(pRow + 2); //red
  1308. *p++ = *(pRow + 1); //green
  1309. *p++ = *(pRow); //blue
  1310. pRow += 3;
  1311. }
  1312. }
  1314. return TRUE;
  1315. }
  1317. /*
  1318.  * 32位图象转换，去掉最高的未用字节
  1319.  */
  1320. BOOL TransformImage32(INFOSTR* pInfo, PBYTE pngImage)
  1321. {
  1322. PBYTE pImage = (PBYTE)pInfo->_pbdata;
  1323. BITMAPINFOHEADER bmpInfo = pInfo->sDIBInfo.bmi;
  1325. ASSERT(bmpInfo.biBitCount == 32);
  1327. DWORD height = bmpInfo.biHeight;
  1328. DWORD width = bmpInfo.biWidth;
  1329. DWORD linesize = DIBSCANLINE_WIDTHBYTES(width * bmpInfo.biBitCount);
  1331. PBYTE pRow = pImage;
  1332. PBYTE p = pngImage;
  1333. for(DWORD row = 0; row < height; row ++)
  1334. {
  1335. pRow = pImage + row * linesize;
  1337. //进度控制
  1338. if(pInfo->fpProgress)
  1339. {
  1340. if ((*pInfo->fpProgress)(RWPROGRESSSIZE, row * 100 / height))
  1341. {
  1342. pInfo->result = ER_USERBREAK;
  1343. return FALSE;
  1344. }
  1345. }
  1347. for(DWORD i = 0; i < width; i++)
  1348. {
  1349. *p++ = *(pRow + 2); //red
  1350. *p++ = *(pRow + 1); //green
  1351. *p++ = *(pRow); //blue
  1352. pRow += 4;
  1353. }
  1354. }
  1356. return TRUE;
  1357. }
  1360. /*
  1361.  * 1、4、8位位图象转换，无需转换，直接拷贝
  1362.  */
  1363. BOOL TransformImage1_4_8(INFOSTR* pInfo, PBYTE pngImage)
  1364. {
  1365. PBYTE pImage = (PBYTE)pInfo->_pbdata;
  1366. BITMAPINFOHEADER bmpInfo = pInfo->sDIBInfo.bmi;
  1368. DWORD height = bmpInfo.biHeight;
  1369. DWORD linesize = DIBSCANLINE_WIDTHBYTES(bmpInfo.biWidth * bmpInfo.biBitCount);
  1371. memcpy(pngImage, pImage, height * linesize);
  1372. return TRUE;
  1373. }