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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
mempager.cpp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：11k
源码类别：

Symbian

开发平台：

C/C++

mempager.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. /****************************************************************************
  37.  *  Includes
  38.  */
  39. #include "mempager.h"
  40. #include "hxfswch.h"
  41. #include "hxassert.h"
  42. #include "qtffrefcounter.h"
  44. #ifndef QTCONFIG_SPEED_OVER_SIZE
  45. #include "mempager_inline.h"
  46. #endif // QTCONFIG_SPEED_OVER_SIZE
  49. /****************************************************************************
  50.  *  Local Defines
  51.  */
  52. #if defined(HELIX_FEATURE_MIN_HEAP)
  53. #define MEMPAGER_DFLT_MIN_PAGE_SIZE 0x00000400  // 1K
  54. #else // HELIX_FEATURE_MIN_HEAP
  55. #define MEMPAGER_DFLT_MIN_PAGE_SIZE 0x0000FFFF  // 64K
  56. #endif // HELIX_FEATURE_MIN_HEAP
  57. #define MEMPAGER_BASE_VIRTUAL_ADDR  0x00000001
  60. /****************************************************************************
  61.  *  Class CMemPager
  62.  */
  63. /****************************************************************************
  64.  *  Constructor/Destructor
  65.  */
  66. CMemPager::CMemPager(void)
  67.     : m_pFileSwitcher(NULL)
  68.     , m_pResponse(NULL)
  69.     , m_State(MEMPGR_Offline)
  70.     , m_pBaseVirtualAddr(NULL)
  71.     , m_pPageVirtualAddr(NULL)
  72.     , m_pPagePhysicalAddr(NULL)
  73.     , m_ulPageSize(0)
  74.     , m_pFaultedPageVirtualAddr(NULL)
  75.     , m_ulFaultedPageSize(0)
  76.     , m_ulAddrSpaceOffset(0)
  77.     , m_ulAddrSpaceSize(0)
  78.     , m_ulMinPageSize(MEMPAGER_DFLT_MIN_PAGE_SIZE)
  79.     , m_pPageBuffer(NULL)
  80.     , m_bSyncMode(FALSE)
  81.     , m_lRefCount(0)
  82. {
  83.     g_nRefCount_qtff++;
  84. }
  87. CMemPager::~CMemPager()
  88. {
  89.     Reset();
  90.     g_nRefCount_qtff--;
  91. }
  94. /****************************************************************************
  95.  *  CMemPager private methods
  96.  */
  97. /****************************************************************************
  98.  *  Reset
  99.  */
  100. void CMemPager::Reset(void)
  101. {
  102.     HX_RELEASE(m_pFileSwitcher);
  103.     HX_RELEASE(m_pResponse);
  104.     HX_RELEASE(m_pPageBuffer);
  105.     m_pBaseVirtualAddr = NULL;
  106.     m_pPageVirtualAddr = NULL;
  107.     m_pPagePhysicalAddr = NULL;
  108.     m_ulPageSize = 0;
  109.     m_pFaultedPageVirtualAddr = NULL;
  110.     m_ulFaultedPageSize = 0;
  111.     m_ulAddrSpaceOffset = 0;
  112.     m_ulAddrSpaceSize = 0;
  113.     m_ulMinPageSize = MEMPAGER_DFLT_MIN_PAGE_SIZE;
  114.     m_State = MEMPGR_Offline;
  115. }
  118. /****************************************************************************
  119.  *  CMemPager methods - Main interface
  120.  */
  121. /****************************************************************************
  122.  *  Init
  123.  */
  124. HX_RESULT CMemPager::Init(IUnknown* pSource,
  125.   ULONG32 ulOffset,
  126.   ULONG32 ulSize,
  127.   UINT8** ppVirtualBaseAddr)
  128. {
  129.     HX_RESULT retVal = HXR_OK;
  131.     if (m_State != MEMPGR_Offline)
  132.     {
  133. retVal = HXR_UNEXPECTED;
  134.     }
  136.     if (SUCCEEDED(retVal))
  137.     {
  138. Reset();
  140. // Find Input Interface
  141. retVal = pSource->QueryInterface(IID_IHXFileSwitcher, 
  142.  (void**) &m_pFileSwitcher);
  143.     }
  145.     if (SUCCEEDED(retVal))
  146.     {
  147. m_ulAddrSpaceOffset = ulOffset;
  148. m_ulAddrSpaceSize = ulSize;
  149. m_pBaseVirtualAddr = (UINT8*) MEMPAGER_BASE_VIRTUAL_ADDR;
  150. m_pFaultedPageVirtualAddr = m_pBaseVirtualAddr;
  151. m_ulFaultedPageSize = m_ulMinPageSize;
  152. if (m_ulFaultedPageSize > m_ulAddrSpaceSize)
  153. {
  154.     m_ulFaultedPageSize = m_ulAddrSpaceSize;
  155. }
  156.    
  157. if (ppVirtualBaseAddr)
  158. {
  159.     *ppVirtualBaseAddr = m_pBaseVirtualAddr;
  160. }
  162. m_State = MEMPGR_Ready;
  163.     }
  165.     return retVal;
  166. }
  168. /****************************************************************************
  169.  *  _PageIn
  170.  */
  171. HX_RESULT CMemPager::_PageIn(UINT8* pVirtualAddr,
  172.      ULONG32 ulSize,
  173.      UINT8* &pPhysicalBaseAddr)
  174. {
  175.     HX_RESULT retVal = HXR_UNEXPECTED;
  177.     if (m_pFileSwitcher && (m_State == MEMPGR_Ready))
  178.     {
  179. retVal = HXR_NO_DATA;
  181. m_pFaultedPageVirtualAddr = pVirtualAddr;
  182. m_ulFaultedPageSize = ulSize;
  183. if (m_ulFaultedPageSize < m_ulMinPageSize)
  184. {
  185.     m_ulFaultedPageSize = m_ulMinPageSize;
  186. }
  187. if ((m_pBaseVirtualAddr + m_ulAddrSpaceSize) < 
  188.     (m_pFaultedPageVirtualAddr + m_ulFaultedPageSize))
  189. {
  190.     m_ulFaultedPageSize = (m_pBaseVirtualAddr + m_ulAddrSpaceSize) -
  191.   m_pFaultedPageVirtualAddr;
  192. }
  194. if (m_ulFaultedPageSize == 0)
  195. {
  196.     m_pFaultedPageVirtualAddr = NULL;
  197.     return HXR_FAIL;
  198. }
  200. // Page in here only if it can be done synchronously
  201. if (SUCCEEDED(m_pFileSwitcher->Advise(HX_FILEADVISE_SYNCACCESS)))
  202. {
  203.     m_bSyncMode = TRUE;
  204.     retVal = _LoadPage();
  205.     if (retVal == HXR_OK)
  206.     {
  207. retVal = HXR_FAIL;
  208. if ((m_ulFaultedPageSize == 0) &&
  209.     m_pPagePhysicalAddr)
  210. {
  211.     pPhysicalBaseAddr = m_pPagePhysicalAddr;
  212.     retVal = HXR_OK;
  213. }
  214.     }
  215.     m_bSyncMode = FALSE;
  217.     m_pFileSwitcher->Advise(HX_FILEADVISE_ASYNCACCESS);
  218. }
  219.     }
  221.     return retVal;
  222. }
  224. /****************************************************************************
  225.  *  _LoadPage
  226.  */
  227. HX_RESULT CMemPager::_LoadPage(void)
  228. {
  229.     ULONG32 ulOffset;
  230.     HX_RESULT retVal;
  232.     m_State = MEMPGR_ProcLoad;
  234.     ReleasePage();
  235.     HX_ASSERT(m_ulFaultedPageSize);
  237.     ulOffset = m_pFaultedPageVirtualAddr - 
  238.        m_pBaseVirtualAddr + 
  239.        m_ulAddrSpaceOffset;
  241.     retVal = m_pFileSwitcher->Seek(ulOffset,
  242.    FALSE,
  243.    (IHXFileResponse*) this);
  245.     if (FAILED(retVal))
  246.     {
  247. retVal = HandleResponse(retVal, NULL);
  248.     }
  250.     return retVal;
  251. }
  254. /****************************************************************************
  255.  *  ReleasePage
  256.  */
  257. void CMemPager::ReleasePage(void)
  258. {
  259.     m_ulPageSize = 0;
  260.     m_pPageVirtualAddr = NULL;
  261.     m_pPagePhysicalAddr = NULL;
  262.     HX_RELEASE(m_pPageBuffer);
  263. }
  266. /****************************************************************************
  267.  *  IHXFileResponse methods
  268.  */
  269. /****************************************************************************
  270.  *  InitDone
  271.  */
  272. STDMETHODIMP CMemPager::InitDone(HX_RESULT status)
  273. {
  274.     HX_RESULT retVal = HXR_UNEXPECTED;
  276.     return retVal;
  277. }
  279. /****************************************************************************
  280.  *  CloseDone
  281.  */
  282. STDMETHODIMP CMemPager::CloseDone(HX_RESULT status)
  283. {
  284.     HX_RESULT retVal = HXR_UNEXPECTED;
  286.     return retVal;
  287. }
  289. /****************************************************************************
  290.  *  ReadDone
  291.  */
  292. STDMETHODIMP CMemPager::ReadDone(HX_RESULT status,
  293.  IHXBuffer* pBuffer)
  294. {
  295.     HX_RESULT retVal = HXR_UNEXPECTED;
  297.     if (m_State == MEMPGR_ProcLoad)
  298.     {
  299. if (SUCCEEDED(status))
  300. {
  301.     status = HXR_FAIL;
  303.     if (pBuffer)
  304.     {
  305. ULONG32 ulSize = pBuffer->GetSize();
  307. if (ulSize == m_ulFaultedPageSize)
  308. {
  309.     HX_ASSERT(m_pPageBuffer == NULL);
  310.     m_pPageBuffer = pBuffer;
  311.     pBuffer->AddRef();
  312.     
  313.     m_pPageVirtualAddr = m_pFaultedPageVirtualAddr;
  314.     m_ulPageSize = m_ulFaultedPageSize;
  315.     m_pPagePhysicalAddr = pBuffer->GetBuffer() - 
  316.   (m_pPageVirtualAddr - 
  317.    m_pBaseVirtualAddr);
  318.     m_pFaultedPageVirtualAddr = NULL;
  319.     m_ulFaultedPageSize = 0;
  320.     status = HXR_OK;
  321. }
  322.     }
  324.     retVal = HandleResponse(status, pBuffer);
  325. }
  326.     }
  328.     return retVal;
  329. }
  331. /****************************************************************************
  332.  *  WriteDone
  333.  */
  334. STDMETHODIMP CMemPager::WriteDone(HX_RESULT status)
  335. {
  336.     HX_RESULT retVal = HXR_UNEXPECTED;
  338.     return retVal;
  339. }
  341. /****************************************************************************
  342.  *  SeekDone
  343.  */
  344. STDMETHODIMP CMemPager::SeekDone(HX_RESULT status)
  345. {
  346.     HX_RESULT retVal = HXR_UNEXPECTED;
  348.     HX_ASSERT(m_State == MEMPGR_ProcLoad);
  350.     if (m_State == MEMPGR_ProcLoad)
  351.     {
  352. HX_ASSERT(m_pFileSwitcher);
  354. if (SUCCEEDED(status))
  355. {
  356.     retVal = m_pFileSwitcher->Read(m_ulFaultedPageSize,
  357.    (IHXFileResponse*) this);
  358. }
  359. else
  360. {
  361.     retVal = HandleResponse(status);
  362. }
  363.     }
  365.     return retVal;
  366. }
  368. /****************************************************************************
  369.  *  HandleResponse
  370.  */
  371. HX_RESULT CMemPager::HandleResponse(HX_RESULT status, IHXBuffer* pBuffer)
  372. {
  373.     HX_RESULT retVal = status;
  375.     if (m_State == MEMPGR_ProcLoad)
  376.     {
  377. m_State = MEMPGR_Ready;
  378. if ((!m_bSyncMode) && m_pResponse)
  379. {
  380.     retVal = m_pResponse->ReadDone(status, pBuffer);
  381. }
  382.     }
  383.     
  384.     return retVal;
  385. }
  388. /****************************************************************************
  389.  *  IHXThreadSafeMethods method
  390.  */
  391. /****************************************************************************
  392.  *  IsThreadSafe
  393.  */
  394. STDMETHODIMP_(UINT32)
  395. CMemPager::IsThreadSafe()
  396. {
  397.     return HX_THREADSAFE_METHOD_FSR_READDONE;
  398. }
  401. /****************************************************************************
  402.  *  IUnknown methods
  403.  */
  404. /////////////////////////////////////////////////////////////////////////
  405. //  Method:
  406. // IUnknown::QueryInterface
  407. //
  408. STDMETHODIMP CMemPager::QueryInterface(REFIID riid, void** ppvObj)
  409. {
  410.     if (IsEqualIID(riid, IID_IHXFileResponse))
  411.     {
  412. AddRef();
  413. *ppvObj = (IHXFileResponse*) this;
  414. return HXR_OK;
  415.     }
  416.     else if (IsEqualIID(riid, IID_IUnknown))
  417.     {
  418. AddRef();
  419. *ppvObj = this;
  420. return HXR_OK;
  421.     }
  422.     else if (IsEqualIID(riid, IID_IHXThreadSafeMethods))
  423.     {
  424. AddRef();
  425. *ppvObj = (IHXThreadSafeMethods*) this;
  426. return HXR_OK;
  427.     }
  429.     *ppvObj = NULL;
  431.     return HXR_NOINTERFACE;
  432. }
  434. /////////////////////////////////////////////////////////////////////////
  435. //  Method:
  436. // IUnknown::AddRef
  437. //
  438. STDMETHODIMP_(ULONG32) CMemPager::AddRef()
  439. {
  440.     return InterlockedIncrement(&m_lRefCount);
  441. }
  443. /////////////////////////////////////////////////////////////////////////
  444. //  Method:
  445. // IUnknown::Release
  446. //
  447. STDMETHODIMP_(ULONG32) CMemPager::Release()
  448. {
  449.     if (InterlockedDecrement(&m_lRefCount) > 0)
  450.     {
  451.         return m_lRefCount;
  452.     }
  454.     delete this;
  455.     return 0;
  456. }