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

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

模拟服务器

开发平台：

C/C++

speventq.h：源码内容
  1. /*******************************************************************************
  2. * SPEventQ.h *
  3. *------------*
  4. *   Description:
  5. *       This is the header file for the SAPI5 event queue implementation.
  6. *-------------------------------------------------------------------------------
  7. *   Copyright (c) Microsoft Corporation. All rights reserved.
  8. *******************************************************************************/
  9. #ifndef SPEventQ_h
  10. #define SPEventQ_h
  12. #ifndef SPHelper_h
  13. #include <SPHelper.h>
  14. #endif
  16. #ifndef SPCollec_h
  17. #include <SPCollec.h>
  18. #endif
  20. //=== Inline helpers for copying and deleting events ============================
  23. //=== Class definition ==========================================================
  25. class CSpEventNode : public CSpEvent
  26. {
  27. public:
  28.     CSpEventNode    * m_pNext;
  29.     static LONG Compare(const CSpEventNode * p1, const CSpEventNode *p2)
  30.     {
  31.         // Assumes offsets DO or DO NOT reset when stream number changes
  32.         if (p1->ulStreamNum < p2->ulStreamNum)
  33.         {
  34.             return -1;
  35.         }
  36.         else if (p1->ulStreamNum > p2->ulStreamNum)
  37.         {
  38.             return 1;
  39.         }
  40.         else if (p1->ullAudioStreamOffset < p2->ullAudioStreamOffset)
  41.         {
  42.             return -1;
  43.         }
  44.         else if (p1->ullAudioStreamOffset > p2->ullAudioStreamOffset)
  45.         {
  46.             return 1;
  47.         }
  48.         return 0;
  49.     }
  50. };
  53. typedef CSpBasicQueue<CSpEventNode, TRUE, TRUE> CSpEventList;
  55. #define DECLARE_SPNOTIFYSOURCE_METHODS(T) 
  56. STDMETHODIMP SetNotifySink(ISpNotifySink * pNotifySink) 
  57. { return T._SetNotifySink(pNotifySink); } 
  58. STDMETHODIMP SetNotifyWindowMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) 
  59. { return T._SetNotifyWindowMessage(hWnd, Msg, wParam, lParam); } 
  60. STDMETHODIMP SetNotifyCallbackFunction(SPNOTIFYCALLBACK * pfnCallback, WPARAM wParam, LPARAM lParam) 
  61. { return T._SetNotifyCallbackFunction(pfnCallback, wParam, lParam); } 
  62. STDMETHODIMP SetNotifyCallbackInterface(ISpNotifyCallback * pSpCallback, WPARAM wParam, LPARAM lParam) 
  63. { return T._SetNotifyCallbackInterface(pSpCallback, wParam, lParam); } 
  64. STDMETHODIMP SetNotifyWin32Event() 
  65. { return T._SetNotifyWin32Event(); } 
  66. STDMETHODIMP WaitForNotifyEvent(DWORD dwMilliseconds) 
  67. { return T._WaitForNotifyEvent(dwMilliseconds); } 
  68. STDMETHODIMP_(HANDLE) GetNotifyEventHandle() 
  69. { return T._GetNotifyEventHandle(); } 
  71. #define DECLARE_SPEVENTSOURCE_METHODS(T) 
  72. DECLARE_SPNOTIFYSOURCE_METHODS(T) 
  73. STDMETHODIMP SetInterest(ULONGLONG ullEventInterest, ULONGLONG ullQueuedInterest) 
  74. { return T._SetInterest(ullEventInterest, ullQueuedInterest); } 
  75. STDMETHODIMP GetEvents(ULONG ulCount, SPEVENT* pEventArray, ULONG * pulFetched) 
  76. { return T._GetEvents(ulCount, pEventArray, pulFetched); } 
  77. STDMETHODIMP GetInfo(SPEVENTSOURCEINFO *pInfo) 
  78. { return T._GetInfo(pInfo); }
  82. class CSpEventSource 
  83. {
  84.   public:
  85.     CSpEventSource(CComObjectRootEx<CComMultiThreadModel> * pParent) :
  86.         m_pParent(pParent)
  87.     {
  88.         m_ullEventInterest = 0; m_ullQueuedInterest = 0;
  89.         m_ulStreamNum = 0;
  90.     }
  91.     HRESULT _SetNotifySink(ISpNotifySink * pNotifySink);
  92.     HRESULT _SetNotifyWindowMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
  93.     HRESULT _SetNotifyCallbackFunction(SPNOTIFYCALLBACK * pfnCallback, WPARAM wParam, LPARAM lParam);
  94.     HRESULT _SetNotifyCallbackInterface(ISpNotifyCallback * pSpCallback, WPARAM wParam, LPARAM lParam);
  95.     HRESULT _SetNotifyWin32Event();
  96.     HRESULT _WaitForNotifyEvent(DWORD dwMilliseconds);
  97.     HANDLE  _GetNotifyEventHandle();
  99.     HRESULT _SetInterest(ULONGLONG ullEventInterest , ULONGLONG ullQueuedInterest);
  100.     HRESULT _GetEvents( ULONG ulCount, SPEVENT* pEventArray, ULONG * pulFetched );
  101.     HRESULT _GetInfo(SPEVENTSOURCEINFO *pInfo );
  103.     /*--- Non interface methods ---*/
  104.     HRESULT _CompleteEvents( ULONGLONG ullPos = 0xFFFFFFFFFFFFFFFF );
  105.     inline void _MoveAllToFreeList(CSpEventList * pList);
  106.     inline void _RemoveAllEvents();
  107.     inline HRESULT _AddEvent(const SPEVENT & Event);
  108.     inline HRESULT _AddEvents(const SPEVENT* pEventArray, ULONG ulCount);
  109.     inline HRESULT _DeserializeAndAddEvent(const BYTE * pBuffer, ULONG * pcbUsed);
  110.     inline HRESULT _GetStreamNumber(const ULONGLONG ullAudioOffset, ULONG *pulStreamNum);
  111.     //=== Data members ==============================
  112.   public:
  113.     ULONGLONG                   m_ullEventInterest;
  114.     ULONGLONG                   m_ullQueuedInterest;
  115.     ULONG                       m_ulStreamNum;
  116.     CSpEventList                m_PendingList;
  117.     CSpEventList                m_CompletedList;
  118.     CSpEventList                m_FreeList;
  119.     CComPtr<ISpNotifySink>      m_cpNotifySink;
  120.     CComPtr<ISpNotifyTranslator> m_cpEventTranslator;   // If non-NULL then Win32 events being used
  121.     CComObjectRootEx<CComMultiThreadModel> * m_pParent;
  122.     CComAutoCriticalSection     m_NotifyObjChangeCrit;  // Critical section used to make sure that
  123.                                                         // the notify object (m_cpNotifySink) not changed
  124.                                                         // while waiting on it.
  125.                                                        
  126. };
  129. //
  130. //=== Inlines =========================================================
  131. //
  133. //
  134. //  WARNING:  If this logic changes, you will need to change the logic in SetNotifyWin32Event also.
  135. //
  136. inline HRESULT CSpEventSource::_SetNotifySink(ISpNotifySink * pNotifySink)
  137. {
  138.     if (SP_IS_BAD_OPTIONAL_INTERFACE_PTR(pNotifySink))
  139.     {
  140.         return E_INVALIDARG;
  141.     }
  142.     else
  143.     {
  144.         m_pParent->Lock();
  145.         m_NotifyObjChangeCrit.Lock();
  146.         m_cpEventTranslator.Release();
  147.         m_cpNotifySink = pNotifySink;
  148.         if (m_cpNotifySink && m_CompletedList.GetHead())
  149.         {
  150.             m_cpNotifySink->Notify();
  151.         }
  152.         m_NotifyObjChangeCrit.Unlock();
  153.         m_pParent->Unlock();
  154.         return S_OK;
  155.     }
  156. }
  158. /****************************************************************************
  159. * CSpEventSource::_SetNotifyWindowMessage *
  160. *-----------------------------------------*
  161. *   Description:
  162. *
  163. *   Returns:
  164. *
  165. ********************************************************************* RAL ***/
  167. inline HRESULT CSpEventSource::_SetNotifyWindowMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
  168. {
  169.     SPDBG_FUNC("CSpEventSource::_SetNotifyWindowMessage");
  170.     HRESULT hr = S_OK;
  171.     CComPtr<ISpNotifyTranslator> cpTranslator;
  172.     hr = cpTranslator.CoCreateInstance(CLSID_SpNotifyTranslator);
  173.     if (SUCCEEDED(hr))
  174.     {
  175.         hr = cpTranslator->InitWindowMessage(hWnd, Msg, wParam, lParam);
  176.     }
  177.     if (SUCCEEDED(hr))
  178.     {
  179.         hr = _SetNotifySink(cpTranslator);
  180.     }
  181.     return hr;
  182. }
  183. /****************************************************************************
  184. * CSpEventSource::_SetNotifyCallbackFunction *
  185. *--------------------------------------------*
  186. *   Description:
  187. *
  188. *   Returns:
  189. *
  190. ********************************************************************* RAL ***/
  192. inline HRESULT CSpEventSource::_SetNotifyCallbackFunction(SPNOTIFYCALLBACK * pfnCallback, WPARAM wParam, LPARAM lParam)
  193. {
  194.     SPDBG_FUNC("CSpEventSource::_SetNotifyCallbackFunction");
  195.     HRESULT hr = S_OK;
  196.     CComPtr<ISpNotifyTranslator> cpTranslator;
  197.     hr = cpTranslator.CoCreateInstance(CLSID_SpNotifyTranslator);
  198.     if (SUCCEEDED(hr))
  199.     {
  200.         hr = cpTranslator->InitCallback(pfnCallback, wParam, lParam);
  201.     }
  202.     if (SUCCEEDED(hr))
  203.     {
  204.         hr = _SetNotifySink(cpTranslator);
  205.     }
  206.     return hr;
  207. }
  208. /****************************************************************************
  209. * CSpEventSource::_SetNotifyCallbackInterface *
  210. *---------------------------------------------*
  211. *   Description:
  212. *
  213. *   Returns:
  214. *
  215. ********************************************************************* RAL ***/
  217. inline HRESULT CSpEventSource::_SetNotifyCallbackInterface(ISpNotifyCallback * pSpCallback, WPARAM wParam, LPARAM lParam)
  218. {
  219.     SPDBG_FUNC("CSpEventSource::_SetNotifyCallbackInterface");
  220.     HRESULT hr = S_OK;
  221.     CComPtr<ISpNotifyTranslator> cpTranslator;
  222.     hr = cpTranslator.CoCreateInstance(CLSID_SpNotifyTranslator);
  223.     if (SUCCEEDED(hr))
  224.     {
  225.         hr = cpTranslator->InitSpNotifyCallback(pSpCallback, wParam, lParam);
  226.     }
  227.     if (SUCCEEDED(hr))
  228.     {
  229.         hr = _SetNotifySink(cpTranslator);
  230.     }
  231.     return hr;
  232. }
  233. /****************************************************************************
  234. * CSpEventSource::_SetNotifyWin32Event *
  235. *--------------------------------------*
  236. *   Description:
  237. *
  238. *   Returns:
  239. *
  240. ********************************************************************* RAL ***/
  242. inline HRESULT CSpEventSource::_SetNotifyWin32Event(void)
  243. {
  244.     SPDBG_FUNC("CSpEventSource::_SetNotifyWin32Event");
  245.     HRESULT hr = S_OK;
  246.     CComPtr<ISpNotifyTranslator> cpTranslator;
  247.     hr = cpTranslator.CoCreateInstance(CLSID_SpNotifyTranslator);
  248.     if (SUCCEEDED(hr))
  249.     {
  250.         hr = cpTranslator->InitWin32Event(NULL, TRUE);
  251.     }
  252.     if (SUCCEEDED(hr))
  253.     {
  254.         //
  255.         //  In this case we do NOT call _SetNotify sink since we want to set the cpEventTranslator
  256.         //
  257.         m_pParent->Lock();
  258.         m_NotifyObjChangeCrit.Lock();
  259.         m_cpEventTranslator = cpTranslator;
  260.         m_cpNotifySink = cpTranslator;
  261.         if (m_cpNotifySink && m_CompletedList.GetHead())
  262.         {
  263.             m_cpNotifySink->Notify();
  264.         }
  265.         m_NotifyObjChangeCrit.Unlock();
  266.         m_pParent->Unlock();
  267.     }
  268.     return hr;
  269. }
  270. /****************************************************************************
  271. * CSpEventSource::_WaitForNotifyEvent *
  272. *-------------------------------------*
  273. *   Description:
  274. *
  275. *   Returns:
  276. *
  277. ********************************************************************* RAL ***/
  279. inline HRESULT CSpEventSource::_WaitForNotifyEvent(DWORD dwMilliseconds)
  280. {
  281.     SPDBG_FUNC("CSpEventSource::_WaitForNotifyEvent");
  282.     HRESULT hr = S_OK;
  283.     m_NotifyObjChangeCrit.Lock();
  284.     if (m_cpEventTranslator)
  285.     {
  286.         hr = m_cpEventTranslator->Wait(dwMilliseconds);
  287.     }
  288.     else
  289.     {
  290.         if (m_cpNotifySink)
  291.         {
  292.             hr = SPERR_ALREADY_INITIALIZED;
  293.         }
  294.         else
  295.         {
  296.             hr = _SetNotifyWin32Event();
  297.             if (SUCCEEDED(hr))
  298.             {
  299.                 hr = m_cpEventTranslator->Wait(dwMilliseconds);
  300.             }
  301.         }
  302.     }
  303.     m_NotifyObjChangeCrit.Unlock();
  304.     return hr;
  305. }
  306. /****************************************************************************
  307. * CSpEventSource::_GetNotifyEventHandle *
  308. *---------------------------------------*
  309. *   Description:
  310. *
  311. *   Returns:
  312. *
  313. ********************************************************************* RAL ***/
  315. inline HANDLE CSpEventSource::_GetNotifyEventHandle()
  316. {
  317.     HANDLE h = NULL;
  318.     SPDBG_FUNC("CSpEventSource::_GetNotifyEventHandle");
  319.     m_NotifyObjChangeCrit.Lock();
  320.     if (!m_cpNotifySink)
  321.     {
  322.         _SetNotifyWin32Event();
  323.     }
  324.     if (m_cpEventTranslator)
  325.     {
  326.         h = m_cpEventTranslator->GetEventHandle();
  327.     }
  328.     m_NotifyObjChangeCrit.Unlock();
  329.     return h;
  330. }
  333. inline HRESULT CSpEventSource::_SetInterest( ULONGLONG ullEventInterest, ULONGLONG ullQueuedInterest )
  334. {
  335.     HRESULT hr = S_OK;
  336.     m_pParent->Lock();
  338.     if(ullEventInterest && SPFEI_FLAGCHECK != (ullEventInterest & SPFEI_FLAGCHECK))
  339.     {
  340.         hr = E_INVALIDARG;
  341.     }
  342.     else if(ullQueuedInterest && SPFEI_FLAGCHECK != (ullQueuedInterest & SPFEI_FLAGCHECK))
  343.     {
  344.         hr = E_INVALIDARG;
  345.     }
  346.     else if ((ullQueuedInterest | ullEventInterest) != ullEventInterest)
  347.     {
  348.         hr = E_INVALIDARG;
  349.     }
  350.     else
  351.     {
  352.         m_ullEventInterest = ullEventInterest;
  353.         m_ullQueuedInterest = ullQueuedInterest;
  354.     }
  355.     m_pParent->Unlock();
  356.     return hr;
  357. }
  360. //
  361. //  Same as AddEvents except:  No param validation, and caller must take the critical section
  362. //  prior to calling.
  363. //
  364. inline HRESULT CSpEventSource::_AddEvents( const SPEVENT* pEventArray, ULONG ulCount )
  365. {
  366.     HRESULT hr = S_OK;
  367.     for( ULONG i = 0; i < ulCount && SUCCEEDED(hr = _AddEvent(pEventArray[i])); ++i ) {}
  368.     return hr;
  369. }
  371. inline HRESULT CSpEventSource::_AddEvent(const SPEVENT & Event)
  372. {
  373.     SPDBG_ASSERT(Event.eEventId < 64);
  374.     SPDBG_ASSERT(Event.elParamType == SPET_LPARAM_IS_UNDEFINED ||
  375.                  Event.elParamType == SPET_LPARAM_IS_TOKEN ||
  376.                  Event.elParamType == SPET_LPARAM_IS_OBJECT ||
  377.                  Event.elParamType == SPET_LPARAM_IS_POINTER ||
  378.                  Event.elParamType == SPET_LPARAM_IS_STRING);
  379. #ifdef _DEBUG
  380.     if (Event.eEventId == SPEI_VOICE_CHANGE)
  381.     {
  382.         SPDBG_ASSERT(Event.elParamType == SPET_LPARAM_IS_TOKEN);
  383.     }
  384.     else if (Event.eEventId == SPEI_RECOGNITION || Event.eEventId == SPEI_FALSE_RECOGNITION || Event.eEventId == SPEI_HYPOTHESIS)
  385.     {
  386.         SPDBG_ASSERT(Event.elParamType == SPET_LPARAM_IS_OBJECT);
  387.     }
  388.     else if (Event.eEventId ==SPEI_REQUEST_UI || Event.eEventId == SPEI_TTS_BOOKMARK)
  389.     {
  390.         SPDBG_ASSERT(Event.elParamType == SPET_LPARAM_IS_STRING);
  391.     }
  392. #endif
  394.     if ( (1i64 << Event.eEventId) & m_ullEventInterest )
  395.     {
  396.         CSpEventNode *pNode = m_FreeList.RemoveHead();
  397.         if (pNode == NULL)
  398.         {
  399.             pNode = new CSpEventNode();
  400.             if (pNode == NULL)
  401.             {
  402.                 return E_OUTOFMEMORY;
  403.             }
  404.         }
  405.         pNode->CopyFrom(&Event);
  406.         m_PendingList.InsertSorted(pNode);
  407.     }
  408.     return S_OK;
  409. }
  411. inline HRESULT CSpEventSource::
  412.     _DeserializeAndAddEvent(const BYTE *pBuffer, ULONG * pcbUsed)
  413. {
  414.     HRESULT hr = S_OK;
  415.     const SPEVENT * pSrcEvent = (const SPEVENT *)pBuffer;
  416.     SPDBG_ASSERT(pSrcEvent->eEventId < 64);
  417.     if ( (1i64 << pSrcEvent->eEventId) & m_ullEventInterest )
  418.     {
  419.         CSpEventNode *pNode = m_FreeList.RemoveHead();
  420.         if (pNode == NULL)
  421.         {
  422.             pNode = new CSpEventNode();
  423.             if (pNode == NULL)
  424.             {
  425.                 hr = E_OUTOFMEMORY;
  426.             }
  427.         }
  428.         if (SUCCEEDED(hr))
  429.         {
  430.             hr = pNode->Deserialize(((const SPSERIALIZEDEVENT64 *)(pBuffer)), pcbUsed);
  431.             if (SUCCEEDED(hr))
  432.             {
  433.                 m_PendingList.InsertSorted(pNode);
  434.             }
  435.             else
  436.             {
  437.                 m_FreeList.InsertHead(pNode);
  438.             }
  439.         }
  440.     }
  441.     else
  442.     {
  443. // WCE compiler does not work propertly with template
  444. #ifndef _WIN32_WCE
  445.         *pcbUsed = SpEventSerializeSize<SPSERIALIZEDEVENT64>(pSrcEvent);
  446. #else
  447.         *pcbUsed = SpEventSerializeSize(pSrcEvent, sizeof(SPSERIALIZEDEVENT64));
  448. #endif
  449.     }
  450.     return hr;
  451. }
  453. inline HRESULT CSpEventSource::_GetEvents( ULONG ulCount, SPEVENT* pEventArray, ULONG *pulFetched )
  454. {
  455.     HRESULT hr = S_OK;
  456.     m_pParent->Lock();
  457.     if( SPIsBadWritePtr( pEventArray, sizeof( SPEVENT ) * ulCount ) ||
  458.         SP_IS_BAD_OPTIONAL_WRITE_PTR(pulFetched) )
  459.     {
  460.         hr = E_INVALIDARG;
  461.     }
  462.     else 
  463.     {
  464.         ULONG ulCopied = 0;
  465.         ULONG ulRemaining = ulCount;
  466.         CSpEventNode * pCur = m_CompletedList.m_pHead;
  467.         CSpEventNode * pLastCopied = NULL;
  468.         while (ulRemaining && pCur)
  469.         {
  470.             pCur->Detach(pEventArray + ulCopied);
  471.             pLastCopied = pCur;
  472.             ulCopied++;
  473.             pCur = pCur->m_pNext;
  474.             ulRemaining--;
  475.         }
  476.         if (ulCopied)
  477.         {
  478.             if (m_FreeList.m_pHead == NULL)
  479.             {
  480.                 m_FreeList.m_pTail = pLastCopied;
  481.             }
  482.             pLastCopied->m_pNext = m_FreeList.m_pHead;
  483.             m_FreeList.m_pHead = m_CompletedList.m_pHead;
  484.             m_CompletedList.m_pHead = pCur;
  485.             m_CompletedList.m_cElements -= ulCopied;
  486.             m_FreeList.m_cElements += ulCopied;
  487.         }
  488.         if (ulCopied < ulCount)
  489.         {
  490.             hr = S_FALSE;
  491.         }
  492.         if (pulFetched) 
  493.         {
  494.             *pulFetched = ulCopied;
  495.         }
  496.     }
  497.     m_pParent->Unlock();
  498.     return hr;
  499. }
  502. inline HRESULT CSpEventSource::_GetInfo( SPEVENTSOURCEINFO * pInfo )
  503. {
  504.     HRESULT hr = S_OK;
  505.     m_pParent->Lock();    
  506.     if( SP_IS_BAD_WRITE_PTR( pInfo ) )
  507.     {
  508.         hr = E_POINTER;
  509.     }
  510.     else
  511.     {
  512.         pInfo->ulCount = m_CompletedList.GetCount();
  513.         pInfo->ullEventInterest = m_ullEventInterest;
  514.         pInfo->ullQueuedInterest= m_ullQueuedInterest;
  515.     }
  516.     m_pParent->Unlock();
  517.     return hr;
  518. }
  522. //
  523. //  The caller must call this function with the critical section owned
  524. //
  525. inline HRESULT CSpEventSource::_CompleteEvents( ULONGLONG ullPos )
  526. {
  527.     HRESULT hr = S_OK;
  529.     if (m_PendingList.m_pHead && m_PendingList.m_pHead->ullAudioStreamOffset <= ullPos)
  530.     {
  531.         BOOL bNotify = FALSE;
  532.         while (m_PendingList.m_pHead &&
  533.                m_PendingList.m_pHead->ullAudioStreamOffset <= ullPos)
  534.         {
  535.             CSpEventNode *pNode = m_PendingList.RemoveHead();
  536.             if(pNode->ulStreamNum != m_ulStreamNum)
  537.             {
  538.                 m_ulStreamNum = pNode->ulStreamNum;
  539.             }
  540.             if ( (1i64 << pNode->eEventId) & m_ullEventInterest )
  541.             {
  542.                 bNotify = TRUE;
  543.                 //
  544.                 //  NOTE:  If we're forwarding events to an event sink then we'll only
  545.                 //  pay attention to the Interest flags.  If we're going to notify, then
  546.                 //  we'll only queue completed events that the user has explicitly asked
  547.                 //  us to store as completed events.
  548.                 //
  549.                 if ( (1i64 << pNode->eEventId) & m_ullQueuedInterest )
  550.                 {
  551.                     m_CompletedList.InsertSorted(pNode);
  552.                 }
  553.                 else
  554.                 {
  555.                     pNode->Clear();
  556.                     m_FreeList.InsertHead(pNode);
  557.                 }
  558.             }
  559.             else
  560.             {
  561.                 pNode->Clear();
  562.                 m_FreeList.InsertHead(pNode);
  563.             }
  564.         }    
  565.         if (bNotify && m_cpNotifySink)
  566.         {
  567.             hr = m_cpNotifySink->Notify();
  568.         }
  569.     }
  570.     return hr;
  571. };
  574. inline void CSpEventSource::_MoveAllToFreeList(CSpEventList * pList)
  575. {
  576.     CSpEventNode * pNode;
  577.     while ((pNode = pList->RemoveHead()) != NULL)
  578.     {
  579.         pNode->Clear();
  580.         m_FreeList.InsertHead(pNode);
  581.     }
  582. }
  583. inline void CSpEventSource::_RemoveAllEvents( )
  584. {
  585.     m_pParent->Lock();
  587.     _MoveAllToFreeList(&m_CompletedList);
  588.     _MoveAllToFreeList(&m_PendingList);
  589.     m_pParent->Unlock();
  590. }
  592. inline HRESULT CSpEventSource::_GetStreamNumber(const ULONGLONG ullAudioOffset, ULONG *pulStreamNum)
  593. {
  594.     CSpEventNode *pNode = m_PendingList.m_pHead;
  595.     *pulStreamNum = m_ulStreamNum;
  596.     for(;pNode && pNode->ullAudioStreamOffset <= ullAudioOffset; pNode = pNode->m_pNext)
  597.     {
  598.         *pulStreamNum = pNode->ulStreamNum;
  599.     }
  600.     return S_OK;
  601. }
  605. #endif //--- This must be the last line in this file