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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
KPakFile.cpp
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：16k
源码类别：

模拟服务器

开发平台：

C/C++

KPakFile.cpp：源码内容
  1. //---------------------------------------------------------------------------
  2. // Sword3 Engine (c) 1999-2000 by Kingsoft
  3. //
  4. // File: KPakFile.cpp
  5. // Date: 2000.08.08
  6. // Code: WangWei(Daphnis)
  7. // Desc: File In Dat Class
  8. //---------------------------------------------------------------------------
  9. #include "KWin32.h"
  10. #include "KFilePath.h"
  11. #include "KPakFile.h"
  12. #ifndef _SERVER
  13. #include "KPakList.h"
  14. #endif
  16. //---------------------------------------------------------------------------
  17. // 文件读取模式 0 = 优先从磁盘读取 1 = 优先从文件包读取
  18. static int m_nPakFileMode = 0;
  20. //---------------------------------------------------------------------------
  21. // 函数: SetFileMode
  22. // 功能: 设置文件读取模式
  23. // 参数: int
  24. // 返回: void
  25. //---------------------------------------------------------------------------
  26. void g_SetPakFileMode(int nFileMode)
  27. {
  28. m_nPakFileMode = nFileMode;
  29. }
  31. #define PAK_INDEX_STORE_IN_RESERVED 0
  33. #ifndef _SERVER
  35. //----modify by Wooy to add Adjust color palette and to get rid of #@$%^& ----2003.8.19
  36. SPRHEAD* SprGetHeader(const char* pszFileName, SPROFFS*& pOffsetTable)
  37. {
  38. pOffsetTable = NULL;
  40. if(pszFileName == NULL || pszFileName[0] == 0)
  41. return NULL;
  43. KPakFile File;
  44. if (!File.Open(pszFileName))
  45. return NULL;
  47. SPRHEAD* pSpr = NULL;
  48. if (File.IsFileInPak())
  49. {
  50. //====到文件包内寻找读取图文件=====
  51. XPackElemFileRef PakRef;
  52. //_ASSERT(g_pPakList);
  53. if (g_pPakList->FindElemFile(pszFileName, PakRef))
  54. {
  55. pSpr = g_pPakList->GetSprHeader(PakRef, pOffsetTable);
  56. if (pSpr)
  57. pSpr->Reserved[PAK_INDEX_STORE_IN_RESERVED] = (WORD)(short)PakRef.nPackIndex;
  58. }
  59. }
  60. else
  61. {
  62. bool bOk = false;
  63. SPRHEAD Header;
  64. //---读文件头，并判断是否为合法的spr图文件---
  65. while(File.Read(&Header, sizeof(SPRHEAD)) == sizeof(SPRHEAD))
  66. {
  67. if (*(int*)&Header.Comment[0] != SPR_COMMENT_FLAG || Header.Colors > 256)
  68. break;
  69. //---为输出缓冲区分配空间---
  70. unsigned int uEntireSize = File.Size();
  71. pSpr = (SPRHEAD*)malloc(uEntireSize);
  72. if (pSpr == NULL)
  73. break;
  75. uEntireSize -= sizeof(SPRHEAD);
  76. //---读取spr剩下的数据---
  77. if (File.Read(&pSpr[1], uEntireSize) == uEntireSize)
  78. {
  79. //----获得图形帧索引表的开始位置---
  80. pOffsetTable = (SPROFFS*)(((char*)(pSpr)) + sizeof(SPRHEAD) + Header.Colors * 3);
  81. Header.Reserved[PAK_INDEX_STORE_IN_RESERVED] = (WORD)(-1);
  82. memcpy(pSpr, &Header, sizeof(SPRHEAD));
  83. bOk = true;
  84. }
  85. break;
  86. };
  88. if (bOk == false && pSpr)
  89. {
  90. free (pSpr);
  91. pSpr = NULL;
  92. }
  93. }
  94. File.Close();
  95. return pSpr;
  96. }
  98. void SprReleaseHeader(SPRHEAD* pSprHeader)
  99. {
  100.     if (pSprHeader)
  101. free(pSprHeader);
  102. }
  104. SPRFRAME* SprGetFrame(SPRHEAD* pSprHeader, int nFrame)
  105. {
  106. SPRFRAME* pFrame = NULL;
  107. if (pSprHeader && g_pPakList)
  108. {
  109. int nPakIndex = (short)pSprHeader->Reserved[PAK_INDEX_STORE_IN_RESERVED];
  110. if (nPakIndex >= 0)
  111. pFrame = g_pPakList->GetSprFrame(nPakIndex, pSprHeader, nFrame);
  112. }
  113. return pFrame;
  114. }
  116. void SprReleaseFrame(SPRFRAME* pFrame)
  117. {
  118.     if (pFrame)
  119. free(pFrame);
  120. }
  122. #include "JpgLib.h"
  123. #include "KDDraw.h"
  125. KSGImageContent* get_jpg_image(const char cszName[], unsigned uRGBMask16)
  126. {
  127. KPakFile File;
  128. unsigned char *pbyFileData = NULL;
  130. if (File.Open(cszName))
  131. {
  132. unsigned int uSize = File.Size();
  133. pbyFileData = (unsigned char *)malloc(uSize);
  134. if (pbyFileData)
  135. {
  136. if (File.Read(pbyFileData, uSize) != uSize)
  137. {
  138. free (pbyFileData);
  139. pbyFileData = NULL;
  140. }
  141. }
  142. }
  144. if (!pbyFileData)
  145.         return NULL;
  147. int nResult = false;
  148.     int nRetCode = false;
  149.     KSGImageContent *pImageResult = NULL;
  151. BOOL bRGB555;
  152. JPEG_INFO JpegInfo;
  154.     if (uRGBMask16 == ((unsigned)-1))
  155.     {
  156.      bRGB555 = (g_pDirectDraw->GetRGBBitMask16() == RGB_555) ? TRUE : FALSE;
  157.     }
  158.     else
  159.     {
  160.         bRGB555 = (uRGBMask16 == RGB_555) ? TRUE : FALSE;
  161.     }
  163.     nRetCode = jpeg_decode_init(bRGB555, TRUE);
  164. if(!nRetCode)
  165.         goto Exit0;
  166.          
  167. nRetCode = jpeg_decode_info(pbyFileData, &JpegInfo);
  168.     if (!nRetCode)
  169.         goto Exit0;
  171. pImageResult = (KSGImageContent *)malloc(KSG_IMAGE_CONTENT_SIZE(JpegInfo.width, JpegInfo.height));
  172.     if (!pImageResult)
  173.         goto Exit0;
  175.     pImageResult->nWidth = JpegInfo.width;
  176.     pImageResult->nHeight = JpegInfo.height;
  178. nRetCode = jpeg_decode_data(pImageResult->Data, &JpegInfo);
  179.     if (!nRetCode)
  180.         goto Exit0;
  182.     nResult = true;
  184. Exit0:
  185. free (pbyFileData);
  186.     if (!nResult && pImageResult)
  187. {
  188. free (pImageResult);
  189. pImageResult = NULL;
  190.     }
  192. return pImageResult;
  193. }
  196. void release_image(KSGImageContent *pImage)
  197. {
  198.     if (pImage)
  199.         free (pImage);
  200. }
  202. #endif
  204. //---------------------------------------------------------------------------
  205. // 功能: 购造函数
  206. //---------------------------------------------------------------------------
  207. KPakFile::KPakFile()
  208. {
  209. #ifndef _SERVER
  210. m_PackRef.nPackIndex = -1;
  211. m_PackRef.uId = 0;
  212. #endif
  213. }
  215. //---------------------------------------------------------------------------
  216. // 功能: 析造函数
  217. //---------------------------------------------------------------------------
  218. KPakFile::~KPakFile()
  219. {
  220. Close();
  221. }
  223. //---------------------------------------------------------------------------
  224. // 功能: 判断此文件是否从包中打开的
  225. //---------------------------------------------------------------------------
  226. bool KPakFile::IsFileInPak()
  227. {
  228. #ifndef _SERVER
  229. return (m_PackRef.nPackIndex >= 0 && m_PackRef.uId);
  230. #else
  231. return false;
  232. #endif
  233. }
  235. //---------------------------------------------------------------------------
  236. // 功能: 打开一个文件, 先寻找当前目录下是否有同名的单独文件,
  237. // 参数: FileName 文件名
  238. // 返回: TRUE 成功
  239. // FALSE 失败
  240. //---------------------------------------------------------------------------
  241. BOOL KPakFile::Open(const char* pszFileName)
  242. {
  243. if (pszFileName == NULL || pszFileName[0] == 0)
  244. return false;
  246. bool bOk = false;
  247. Close();
  249. #ifndef _SERVER
  250. if (m_nPakFileMode == 0) //0=优先从磁盘读取
  251. {
  252. #endif
  253. bOk = (m_File.Open((char*)pszFileName) != FALSE);
  254. #ifndef _SERVER
  255. if (bOk == false && g_pPakList)
  256. {
  257. bOk = g_pPakList->FindElemFile(pszFileName, m_PackRef);
  258. }
  259. }
  260. else //1=优先从文件包读取
  261. {
  262. if (g_pPakList)
  263. bOk = g_pPakList->FindElemFile(pszFileName, m_PackRef);
  264. if (bOk == false)
  265. bOk = (m_File.Open((char*)pszFileName) != FALSE);
  266. }
  267. #endif
  268. return bOk;
  269. }
  271. //---------------------------------------------------------------------------
  272. // 功能: 从文件中读取数据
  273. // 参数: pBuffer 缓冲区指针
  274. // dwSize 要读取的长度
  275. // 返回: 读到的字节长度
  276. //---------------------------------------------------------------------------
  277. DWORD KPakFile::Read(void* pBuffer, unsigned int uSize)
  278. {
  279. #ifndef _SERVER
  280. if (m_PackRef.nPackIndex >= 0)
  281. {
  282. if (g_pPakList->ElemFileRead(m_PackRef, pBuffer, uSize) == false)
  283. uSize = 0;
  284. }
  285. else
  286. #endif
  287. {
  288. uSize = m_File.Read(pBuffer, uSize);
  289. }
  290. return uSize;
  291. }
  293. //---------------------------------------------------------------------------
  294. // 功能: 文件读指针定位
  295. // 参数: lOffset 偏移量
  296. // dwMethod 定位方法
  297. // 返回: 文件的指针
  298. //---------------------------------------------------------------------------
  299. DWORD KPakFile::Seek(int nOffset, unsigned int uMethod)
  300. {
  301. #ifndef _SERVER
  302. if (m_PackRef.nPackIndex >= 0)
  303. {
  304. if (uMethod == FILE_BEGIN)
  305. m_PackRef.nOffset = nOffset;
  306. else if (uMethod == FILE_END)
  307. m_PackRef.nOffset = m_PackRef.nSize + nOffset;
  308. else
  309. m_PackRef.nOffset += nOffset;
  310. if (m_PackRef.nOffset > m_PackRef.nSize)
  311. m_PackRef.nOffset =  m_PackRef.nSize;
  312. else if (m_PackRef.nOffset < 0)
  313. m_PackRef.nOffset = 0;
  314. nOffset = m_PackRef.nOffset;
  315. }
  316. else
  317. #endif
  318. {
  319. nOffset = m_File.Seek(nOffset, uMethod);
  320. }
  321. return nOffset;
  322. }
  324. //---------------------------------------------------------------------------
  325. // 功能: 返回文件的指针
  326. // 返回: 文件的指针
  327. //---------------------------------------------------------------------------
  328. DWORD KPakFile::Tell()
  329. {
  330. int nOffset;
  331. #ifndef _SERVER
  332. if (m_PackRef.nPackIndex >= 0)
  333. nOffset = m_PackRef.nOffset;
  334. else
  335. #endif
  336. nOffset = m_File.Tell();
  337. return nOffset;
  338. }
  340. //---------------------------------------------------------------------------
  341. // 功能: 返回文件大小
  342. // 返回: 文件的大小 in bytes
  343. //---------------------------------------------------------------------------
  344. DWORD KPakFile::Size()
  345. {
  346. unsigned int uSize;
  347. #ifndef _SERVER
  348. if (m_PackRef.nPackIndex >= 0)
  349. uSize = m_PackRef.nSize;
  350. else
  351. #endif
  352. uSize = m_File.Size();
  353. return uSize;
  354. }
  355. //---------------------------------------------------------------------------
  356. // 功能: 关闭一个文件
  357. //---------------------------------------------------------------------------
  358. void KPakFile::Close()
  359. {
  360. #ifndef _SERVER
  361. if (m_PackRef.nPackIndex >= 0)
  362. {
  363. m_PackRef.nPackIndex = -1;
  364. m_PackRef.uId = 0;
  365. }
  366. else
  367. #endif
  368. {
  369. m_File.Close();
  370. }
  371. }
  374. //---------------------------------------------------------------------------
  375. // 每次读取数据块的大小
  376. #define BLOCK_SIZE (0x10000L)
  378. //---------------------------------------------------------------------------
  379. // 功能: 打开一个包中的文件
  380. // 参数: FileName 文件名
  381. // 返回: TRUE 成功
  382. // FALSE 失败
  383. //---------------------------------------------------------------------------
  384. /*BOOL KPakFile::OpenPak(LPSTR FileName)
  385. {
  386. if (g_pPakList == NULL)
  387. return FALSE;
  389. KAutoMutex AutoMutex(g_pPakList->GetMutexPtr());
  391. // 在所有文件包中查找要打开的文件是否存在
  392. m_nPackage = g_pPakList->Search(FileName, &m_dwFileOfs, &m_dwFileLen);
  393. if (m_nPackage < 0)
  394. return FALSE;
  396. // m_nBlocks 即块的个数, 源文件每64K打为一个包
  397. // m_nBlocks * 2 为块长度表的大小(每块的大小用一个WORD记录)
  398. m_nBlocks = (m_dwFileLen + 0xffff) >> 16;
  400. // 给 block buffer 分配内存
  401. if (!m_MemBlock.Alloc(m_nBlocks * 2))
  402. return FALSE;
  404. // 给 file buffer 分配内存64K, 为解压做准备
  405. if (!m_MemFile.Alloc(BLOCK_SIZE))
  406. return FALSE;
  408. // 给 read buffer 分配内存64K, 为解压做准备
  409. if (!m_MemRead.Alloc(BLOCK_SIZE))
  410. return FALSE;
  412. // 文件缓冲区指针
  413. m_pBuffer = (PBYTE)m_MemFile.GetMemPtr();
  415. // 每块的长度表
  416. m_pBlocks = (PWORD)m_MemBlock.GetMemPtr();
  418. // 移动到文件开始
  419. g_pPakList->Seek(m_dwFileOfs, FILE_BEGIN);
  421. // 读入每块的大小
  422. g_pPakList->Read(m_pBlocks, m_nBlocks * 2);
  424. // 第一块压缩数据的偏移量
  425. m_dwFileOfs = m_dwFileOfs + m_nBlocks * 2;
  427. // 读取压缩数据起始位置
  428. m_dwDataPtr = m_dwFileOfs;
  430. // 读指针的位置(解码后的位置) = 0;
  431. m_dwFilePtr = 0;
  433. // 成功打开文件
  434. return TRUE;
  435. }
  436. //---------------------------------------------------------------------------
  437. // 函数: ReadPak
  438. // 功能: 从文件中读取数据
  439. // 参数: pBuffer 缓冲区指针
  440. // dwSize 要读取的长度
  441. // 返回: 读到的字节长度
  442. //---------------------------------------------------------------------------
  443. DWORD KPakFile::ReadPak(PVOID pBuffer, DWORD dwSize)
  444. {
  445. KAutoMutex AutoMutex(g_pPakList->GetMutexPtr());
  447. // 如果是包中文件就从包中读
  448. UINT nBlock = 0;
  449. DWORD dwReadSize = 0;
  450. DWORD dwBlockPos = 0;
  451. PBYTE pOutBuf = (PBYTE)pBuffer;
  453. // 如果读取长度大于剩余文件长度
  454. if (m_dwFilePtr + dwSize > m_dwFileLen)
  455. {
  456. dwSize =  m_dwFileLen - m_dwFilePtr;
  457. dwReadSize = dwSize;
  458. }
  459. else
  460. {
  461. dwReadSize = dwSize;
  462. }
  464. // 已经读入的块数
  465. nBlock = m_dwFilePtr >> 16;
  467. // 已经读入小于64K块的长度
  468. dwBlockPos = m_dwFilePtr & 0xffff;
  470. // 以前读过小于64K的数据
  471. if (dwBlockPos)
  472. {
  473. // 要读的数据长度小于64K
  474. if (dwBlockPos + dwSize <= BLOCK_SIZE)
  475. {
  476. // m_pBuffer为64K大小, 上次已读入了
  477. g_MemCopyMmx(pOutBuf, m_pBuffer + dwBlockPos, dwSize);
  478. m_dwFilePtr += dwSize;
  480. // 如果此时 m_dwFilePtr 为64K 的倍数
  481. if ((m_dwFilePtr & 0xffff) == 0)
  482. m_dwDataPtr += (m_pBlocks[nBlock] == 0)? BLOCK_SIZE : m_pBlocks[nBlock];
  484. return dwSize;
  485. }
  487. // 要读的数据长度大于64K
  488. g_MemCopyMmx(pOutBuf, m_pBuffer + dwBlockPos, BLOCK_SIZE - dwBlockPos);
  489. pOutBuf += BLOCK_SIZE - dwBlockPos;
  490. m_dwDataPtr += (m_pBlocks[nBlock] == 0)? BLOCK_SIZE : m_pBlocks[nBlock];
  491. m_dwFilePtr = (++nBlock) << 16;
  492. dwSize -= (BLOCK_SIZE - dwBlockPos);
  493. }
  495. // 读入其余部分
  496. while (dwSize > 0xffff) // 大于64K
  497. {
  498. ReadBlock(pOutBuf, nBlock);
  499. pOutBuf += BLOCK_SIZE;
  500. m_dwDataPtr += (m_pBlocks[nBlock] == 0)? BLOCK_SIZE : m_pBlocks[nBlock];
  501. m_dwFilePtr = (++nBlock) << 16;
  502. dwSize -= BLOCK_SIZE;
  503. }
  505. // 刚好读完则返回
  506. if (dwSize == 0)
  507. {
  508. return dwReadSize;
  509. }
  511. // 读一个64K数据块到缓冲区
  512. ReadBlock(m_pBuffer, nBlock);
  514. // 拷贝缓冲区数据到目标地址
  515. g_MemCopyMmx(pOutBuf, m_pBuffer, dwSize);
  517. // 调整文件指针
  518. m_dwFilePtr += dwSize;
  520. // 返回读取的字节长度
  521. return dwReadSize;
  522. }
  523. //---------------------------------------------------------------------------
  524. // 函数: Seek
  525. // 功能: 文件读指针定位
  526. // 参数: lOffset 偏移量
  527. // dwMethod 定位方法
  528. // 返回: 文件的指针
  529. //---------------------------------------------------------------------------
  530. DWORD KPakFile::SeekPak(long lOffset, DWORD dwMethod)
  531. {
  532. KAutoMutex AutoMutex(g_pPakList->GetMutexPtr());
  534. if (m_nPackage < 0)
  535. {
  536. return m_File.Seek(lOffset, dwMethod);
  537. }
  539. int nFilePtr = m_dwFilePtr;
  541. switch (dwMethod)
  542. {
  543. case FILE_BEGIN:
  544. nFilePtr = lOffset;
  545. break;
  547. case FILE_END:
  548. nFilePtr = m_dwFileLen + lOffset;
  549. break;
  551. case FILE_CURRENT:
  552. nFilePtr = m_dwFilePtr + lOffset;
  553. break;
  554. }
  556. if (nFilePtr < 0)
  557. {
  558. nFilePtr = 0;
  559. }
  560. else if (nFilePtr > (int)m_dwFileLen)
  561. {
  562. nFilePtr = m_dwFileLen;
  563. }
  565. m_dwFilePtr = nFilePtr;
  566. m_dwDataPtr = m_dwFileOfs;
  568. int nBlocks = nFilePtr >> 16;
  569. for (int i = 0; i < nBlocks; i++)
  570. {
  571. m_dwDataPtr += (m_pBlocks[i] == 0)? BLOCK_SIZE : m_pBlocks[i];
  572. }
  573. if (nFilePtr & 0xffff)
  574. {
  575. ReadBlock(m_pBuffer, nBlocks);
  576. }
  578. return m_dwFilePtr;
  579. }
  581. //---------------------------------------------------------------------------
  582. // 函数: Save
  583. // 功能: 保存文件
  584. // 参数: FileName 文件名
  585. // 返回: TRUE 成功
  586. // FALSE 失败
  587. //---------------------------------------------------------------------------
  588. */
  589. BOOL KPakFile::Save(const char* pszFileName)
  590. {
  591. /* if (m_nPackage < 0)
  592. return TRUE;
  594. if (!m_File.Create(pszFileName))
  595. return FALSE;
  597. DWORD dwSize = m_dwFileLen;
  598. int nBlock = 0;
  600. // set data ptr
  601. m_dwDataPtr = m_dwFileOfs;
  603. // read blocks and write to file
  604. while (dwSize > BLOCK_SIZE)
  605. {
  606. ReadBlock(m_pBuffer, nBlock);
  607. dwSize -= BLOCK_SIZE;
  608. m_File.Write(m_pBuffer, BLOCK_SIZE);
  609. m_dwDataPtr += (m_pBlocks[nBlock] == 0)? BLOCK_SIZE : m_pBlocks[nBlock];
  610. nBlock++;
  611. }
  613. // read last block and write to file
  614. ReadBlock(m_pBuffer, nBlock);
  615. m_File.Write(m_pBuffer, dwSize);*/
  617. return FALSE;
  618. }
  620. /*
  621. //---------------------------------------------------------------------------
  622. // 函数: ReadBlock
  623. // 功能: 读一个压缩数据块
  624. // 参数: pBuffer 缓冲区指针
  625. // nBlock 块索引
  626. // 返回: void
  627. //---------------------------------------------------------------------------
  628. void KPakFile::ReadBlock(PBYTE pBuffer, int nBlock)
  629. {
  630. TCodeInfo CodeInfo;
  632. // 设置当前使用的文件包
  633. g_pPakList->SetActivePak(m_nPackage);
  635. // 填充解压缩接口结构
  636. CodeInfo.lpPack = (PBYTE)m_MemRead.GetMemPtr();
  637. CodeInfo.dwPackLen = m_pBlocks[nBlock];
  638. CodeInfo.lpData = pBuffer;
  639. CodeInfo.dwDataLen = BLOCK_SIZE;
  641. // 检查是否压缩过
  642. if (CodeInfo.dwPackLen == 0) // 没有压缩
  643. {
  644. g_pPakList->Seek(m_dwDataPtr, FILE_BEGIN);
  645. g_pPakList->Read(CodeInfo.lpData, CodeInfo.dwDataLen);
  646. return;
  647. }
  649. // 最后一块的实际长度（只有LHA用）
  650. if (nBlock == (m_nBlocks - 1))
  651. {
  652. CodeInfo.dwDataLen = m_dwFileLen - nBlock * BLOCK_SIZE;
  653. }
  655. // 移动指针，读取压缩数据，再解压缩
  656. g_pPakList->Seek(m_dwDataPtr, FILE_BEGIN);
  657. g_pPakList->Read(CodeInfo.lpPack, CodeInfo.dwPackLen);
  658. g_pPakList->Decode(&CodeInfo);
  659. }
  660. //---------------------------------------------------------------------------
  661. */