hxovmgr.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:12k
源码类别:

Symbian

开发平台:

C/C++

  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 ***** */ 
  35. #include "hxtypes.h"
  36. #include "hxcom.h"
  37. #include "hxresult.h"
  38. #include "hxstrutl.h"
  39. #include "hxstring.h"
  40. #include "hxcomm.h"
  41. #include "ihxpckts.h"
  42. #include "hxfiles.h"
  43. #include "hxcore.h"
  44. #include "hxmon.h"
  45. #include "hxprefs.h"
  46. #include "hxwin.h"
  47. #include "hxslist.h"
  48. #include "hxthread.h"
  49. #include "hxovmgr.h"
  50. #include "hxtick.h"
  51. #define DEFAULT_THERMOSTAT_FACTOR 2.0
  52. //#define _DEBUG_LOG 
  53. HXOverlayManager::HXOverlayManager(IUnknown* pContext)
  54.     :   m_lRefCount(0)
  55.     ,   m_pContext(pContext)
  56.     ,   m_pCurrentOverlayOwner(NULL)
  57.     ,   m_CallbackHandle(NULL)
  58.     ,   m_pScheduler(NULL)
  59.     ,   m_pOldOverlaySite(NULL)
  60.     ,   m_pNewOverlaySite(NULL)
  61.     ,   m_fThemoStatFactor(DEFAULT_THERMOSTAT_FACTOR)
  62.     ,   m_bChangingOwner(FALSE)
  63. {
  64.     m_pContext->AddRef();
  65. #if defined(THREADS_SUPPORTED) || defined(_UNIX_THREADS_SUPPORTED)
  66.     HXMutex::MakeMutex(m_pMutex);
  67. #else
  68.     HXMutex::MakeStubMutex(m_pMutex);
  69. #endif
  70. }
  71. HXOverlayManager::~HXOverlayManager()
  72.     Close();
  73. }
  74. void HXOverlayManager::Initialize()
  75. {
  76.     m_pContext->QueryInterface(IID_IHXScheduler, (void**)&m_pScheduler);
  77.     IHXPreferences*    pPreferences    = NULL;
  78.     IHXBuffer*         pBuffer         = NULL;
  79.     if (HXR_OK == m_pContext->QueryInterface(IID_IHXPreferences,(void**)&pPreferences))
  80.     {   
  81.         if (pPreferences->ReadPref("ThermoStatFactor", pBuffer) == HXR_OK)
  82.         {
  83.             m_fThemoStatFactor = atof((char*)pBuffer->GetBuffer());  /* is this ANSI? if not use the next line */
  84.             //sscanf((char*)pBuffer->GetBuffer(), "%f", &m_fThemoStatFactor); 
  85.         }
  86.         HX_RELEASE(pBuffer);
  87.     }
  88.     HX_RELEASE(pPreferences);
  89. }
  90. void
  91. HXOverlayManager::Close()
  92.     CSiteStats* pStats;
  93.     CStatPoint* pPoint;
  94.     while (m_ListOfSiteStats.GetCount())
  95.     {
  96.         pStats = (CSiteStats*) m_ListOfSiteStats.RemoveHead();
  97.         while(pStats->samples.GetCount())
  98.         {
  99.             pPoint = (CStatPoint*) pStats->samples.RemoveHead();
  100.             HX_DELETE(pPoint);
  101.         }
  102.         HX_DELETE(pStats);
  103.     }
  104.     if (m_CallbackHandle)
  105.     {
  106.         m_pScheduler->Remove(m_CallbackHandle);
  107.         m_CallbackHandle = 0;
  108.     }
  109.     HX_RELEASE(m_pContext);
  110.     HX_RELEASE(m_pScheduler);
  111.     HX_DELETE(m_pMutex);
  112. }
  113. /*
  114.  * IUnknown methods
  115.  */
  116. /////////////////////////////////////////////////////////////////////////
  117. // Method:
  118. // IUnknown::QueryInterface
  119. // Purpose:
  120. // Implement this to export the interfaces supported by your 
  121. // object.
  122. //
  123. STDMETHODIMP HXOverlayManager::QueryInterface(REFIID riid, void** ppvObj)
  124. {
  125.     QInterfaceList qiList[] =
  126.         {
  127.             { GET_IIDHANDLE(IID_IHXOverlayManager), (IHXOverlayManager*)this },
  128.             { GET_IIDHANDLE(IID_IHXCallback), (IHXCallback*)this },
  129.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXOverlayManager*)this },
  130.         };
  131.     
  132.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  133. }
  134. /////////////////////////////////////////////////////////////////////////
  135. // Method:
  136. // IUnknown::AddRef
  137. // Purpose:
  138. // Everyone usually implements this the same... feel free to use
  139. // this implementation.
  140. //
  141. STDMETHODIMP_(ULONG32) HXOverlayManager::AddRef()
  142. {
  143.     return InterlockedIncrement(&m_lRefCount);
  144. }
  145. /////////////////////////////////////////////////////////////////////////
  146. // Method:
  147. // IUnknown::Release
  148. // Purpose:
  149. // Everyone usually implements this the same... feel free to use
  150. // this implementation.
  151. //
  152. STDMETHODIMP_(ULONG32) HXOverlayManager::Release()
  153. {
  154.     if (InterlockedDecrement(&m_lRefCount) > 0)
  155.     {
  156. return m_lRefCount;
  157.     }
  158.     delete this;
  159.     return 0;
  160. }
  161. STDMETHODIMP HXOverlayManager::HasOverlay(THIS_
  162.                 IHXOverlayResponse* pResp
  163.                 ) 
  164. {
  165.     m_pMutex->Lock();
  166.     HX_RESULT res = HXR_FAIL;
  167.     if (!m_pCurrentOverlayOwner)
  168.     {
  169.         m_pCurrentOverlayOwner = pResp;
  170.         res = HXR_OK;
  171.     }
  172.     m_pMutex->Unlock();
  173.     return res;
  174. }
  175. STDMETHODIMP HXOverlayManager::AddStats(THIS_
  176.                                          IHXOverlayResponse* pResp,
  177.                                          UINT32    ulNumPixels) 
  178. {
  179.     if (m_bChangingOwner)
  180.         return HXR_OK;
  181.     m_pMutex->Lock();
  182.     CSiteStats* pStats;
  183.     CStatPoint* pPoint;
  184.     UINT32 time = HX_GET_TICKCOUNT();
  185.     BOOL bExisted = FALSE;
  186.     CHXSimpleList::Iterator i;
  187.     for (i = m_ListOfSiteStats.Begin(); i != m_ListOfSiteStats.End(); ++i)
  188.     {
  189.         pStats = (CSiteStats*)*i;
  190.         if (pStats->pResp == pResp)
  191.         {
  192. #ifdef _DEBUG_LOG
  193.             FILE* f = fopen("c:\overlay.txt", "a+");
  194.             if (f)
  195.             {
  196.                 fprintf(f, "Owner: %p  Pixels: %dn", pResp, ulNumPixels);
  197.                 fclose(f);
  198.             }
  199. #endif
  200.             AddStatPoint(pStats, ulNumPixels, time);
  201.             bExisted = TRUE;
  202.         }
  203.         while(pStats->samples.GetCount())
  204.         {
  205.             pPoint = (CStatPoint*) pStats->samples.GetHead();
  206.             if (pPoint->ulTime + 1000 > time)
  207.             {
  208.                 break;
  209.             }
  210.             pStats->ulNumPixelsPerSecond -= pPoint->ulPixels;
  211.             pStats->samples.RemoveHead();
  212.             HX_DELETE(pPoint);
  213.         }
  214. #ifdef _DEBUG_LOG
  215.             FILE* f = fopen("c:\overlay.txt", "a+");
  216.             if (f)
  217.             {
  218.                 fprintf(f, "*Owner: %p  Pixels: %d Count: %dn", pStats->pResp, pStats->ulNumPixelsPerSecond, pStats->samples.GetCount());
  219.                 fclose(f);
  220.             }
  221. #endif
  222.     }
  223.     if (!bExisted)
  224.     {
  225.         pStats                          = new CSiteStats;
  226.         pStats->ulFirstTime             = time;
  227.         pStats->ulNumPixelsPerSecond    = 0;
  228.         pStats->pResp                   = pResp;
  229.         m_ListOfSiteStats.AddTail(pStats);
  230.         AddStatPoint(pStats, ulNumPixels, time);
  231.     }
  232.     ValidateCurrentOwner();
  233.     m_pMutex->Unlock();
  234.     return HXR_OK;
  235. }
  236. void HXOverlayManager::AddStatPoint(CSiteStats* pStats, UINT32 ulNumPixels, UINT32 ulTime)
  237. {
  238.     CStatPoint* pPoint;
  239.     pPoint = new CStatPoint;
  240.     pPoint->ulTime = ulTime;
  241.     pPoint->ulPixels = ulNumPixels;
  242.     pStats->ulNumPixelsPerSecond  += pPoint->ulPixels;
  243.     pStats->samples.AddTail(pPoint);
  244. }
  245. void HXOverlayManager::ValidateCurrentOwner()
  246. {
  247.     if (!m_pCurrentOverlayOwner)
  248.     {
  249.         return;
  250.     }
  251.     IHXOverlayResponse* pMaxResp = NULL;
  252.     UINT32  ulMaxNumPixelsPerSecond = 0;
  253.     UINT32  ulCurrentNumPixelsPerSecond = 0;
  254.     CSiteStats* pStats = NULL;
  255.     CHXSimpleList::Iterator i;
  256.     for (i = m_ListOfSiteStats.Begin(); i != m_ListOfSiteStats.End(); ++i)
  257.     {
  258. pStats = (CSiteStats*)*i;
  259.         if (pStats->pResp == m_pCurrentOverlayOwner)
  260.         {
  261.             ulCurrentNumPixelsPerSecond = pStats->ulNumPixelsPerSecond;
  262.         }
  263.         if (ulMaxNumPixelsPerSecond < pStats->ulNumPixelsPerSecond)
  264.         {
  265.             ulMaxNumPixelsPerSecond = pStats->ulNumPixelsPerSecond;
  266.             pMaxResp = pStats->pResp;
  267.         }
  268.     }
  269. #ifdef _DEBUG_LOG
  270.         FILE* f = fopen("c:\overlay.txt", "a+");
  271.         fprintf(f, "CurrentOvOwner = %p  Pels: %d ttt Max: %p Pels: %dn", m_pCurrentOverlayOwner, ulCurrentNumPixelsPerSecond, pMaxResp, ulMaxNumPixelsPerSecond);
  272.         fclose(f);
  273. #endif
  274.     UINT32  ulTempMaxNumPixelsPerSecond = 0;
  275.     if ((double)ulMaxNumPixelsPerSecond > (double)ulCurrentNumPixelsPerSecond * 2)
  276.     {
  277. #ifdef _DEBUG_LOG
  278.         FILE* f = fopen("c:\overlay.txt", "a+");
  279.         if (f)
  280.         {
  281.             CHXSimpleList::Iterator i;
  282.             for (i = m_ListOfSiteStats.Begin(); i != m_ListOfSiteStats.End(); ++i)
  283.             {
  284.         pStats = (CSiteStats*)*i;
  285.                 fprintf(f, "Owner: %p  Pixels: %d NumSamples: %d n", pStats->pResp , pStats->ulNumPixelsPerSecond, pStats->samples.GetCount());
  286.                 if (pStats->pResp == m_pCurrentOverlayOwner)
  287.                 {
  288.                     fprintf(f, "** Current Owner: %p Current Num: %dn", pStats->pResp , pStats->ulNumPixelsPerSecond);
  289.                 }
  290.                 if (ulTempMaxNumPixelsPerSecond < pStats->ulNumPixelsPerSecond)
  291.                 {
  292.                     fprintf(f, "** Current Max Owner: %p Current Num: %dn", pStats->pResp , pStats->ulNumPixelsPerSecond);
  293.                     ulTempMaxNumPixelsPerSecond = pStats->ulNumPixelsPerSecond;
  294.                 }
  295.             }
  296.             fclose(f);
  297.         }
  298. #endif
  299.         ScheduleCallback(m_pCurrentOverlayOwner,   pMaxResp);
  300.     }
  301. }
  302. void HXOverlayManager::ScheduleCallback(IHXOverlayResponse* pOld, IHXOverlayResponse* pNew)
  303. {
  304.     if (m_pScheduler && !m_CallbackHandle)
  305.     {
  306.         m_CallbackHandle = m_pScheduler->RelativeEnter(this, 0);
  307.         m_pOldOverlaySite = pOld;
  308.         m_pNewOverlaySite = pNew;
  309.     }
  310. }
  311. /************************************************************************
  312.  *  Method:
  313.  *    IHXCallback::Func
  314.  */
  315. STDMETHODIMP HXOverlayManager::Func(void)
  316. {
  317.     m_bChangingOwner = TRUE;
  318.     m_pMutex->Lock();
  319.     AddRef();
  320.     if (m_pOldOverlaySite && m_pNewOverlaySite)
  321.     {
  322.        if (HXR_OK == m_pOldOverlaySite->OverlayRevoked())
  323.        {
  324.             m_pCurrentOverlayOwner = NULL;
  325.             if (HXR_OK == m_pNewOverlaySite->OverlayGranted())
  326.             {
  327.                 m_pCurrentOverlayOwner = m_pNewOverlaySite;
  328.             }
  329.        }
  330.     }
  331.     m_pNewOverlaySite        = NULL;
  332.     m_pOldOverlaySite        = NULL;
  333.     m_CallbackHandle         = 0;
  334.     Release();
  335.     
  336.     m_pMutex->Unlock();
  337.     m_bChangingOwner = FALSE;
  338.     return HXR_OK;
  339. }
  340. STDMETHODIMP HXOverlayManager::RemoveOverlayRequest(THIS_ IHXOverlayResponse* pResp ) 
  341. {
  342.     m_pMutex->Lock();
  343.     
  344.     HX_RESULT res = HXR_FAIL;
  345.     if (pResp == m_pNewOverlaySite && m_CallbackHandle)
  346.     {
  347.         m_pScheduler->Remove(m_CallbackHandle);
  348.         m_CallbackHandle = 0;
  349.         m_pNewOverlaySite = NULL;
  350.         m_pOldOverlaySite = NULL;    
  351.     }
  352.     if (m_pCurrentOverlayOwner == pResp)
  353.     {
  354.         m_pCurrentOverlayOwner = NULL;
  355.     }
  356.     CSiteStats* pStats;
  357.     CStatPoint* pPoint;
  358.     LISTPOSITION pos = NULL;
  359.     
  360.     pos = m_ListOfSiteStats.GetHeadPosition();
  361.     while (pos)
  362.     {
  363.         pStats = (CSiteStats*)m_ListOfSiteStats.GetAt(pos);
  364.         if (pStats->pResp == pResp)
  365.         {
  366.             res = HXR_OK;
  367.             while(pStats->samples.GetCount())
  368.             {
  369.                 pPoint = (CStatPoint*) pStats->samples.RemoveHead();
  370.                 HX_DELETE(pPoint);
  371.             }
  372.             HX_DELETE(pStats);
  373.             m_ListOfSiteStats.RemoveAt(pos);
  374.             break;
  375.         }
  376.         m_ListOfSiteStats.GetNext(pos);
  377.     }
  378.     m_pMutex->Unlock();
  379.     return res;
  380. }