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

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

Symbian

开发平台：

C/C++

sinkctl.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. #include "hxcom.h"
  37. #include "hxtypes.h"
  38. #include "hxclsnk.h"
  39. #include "hxengin.h"
  40. #include "hxcore.h"
  41. #include "hxengin.h"
  42. #include "hxsched.h"
  43. #include "hxerror.h"
  44. #include "hxslist.h"
  45. #include "hxcbobj.h"
  46. #include "sinkctl.h"
  48. #include "hxheap.h"
  49. #ifdef _DEBUG
  50. #undef HX_THIS_FILE
  51. static const char HX_THIS_FILE[] = __FILE__;
  52. #endif
  54. CHXAdviseSinkControl::PlayerAdviseSink::PlayerAdviseSink(
  55.     IHXClientAdviseSink* pAdviseSink,
  56.     BOOL bInterruptSafe)
  57. {
  58.     m_pAdviseSink     = pAdviseSink;
  59.     m_pAdviseSink->AddRef();
  60.     m_bInterruptSafe     = bInterruptSafe;
  61.     m_pPendingAdviseList    = NULL;
  62. }
  64. CHXAdviseSinkControl::PlayerAdviseSink::~PlayerAdviseSink()
  65. {
  66.     while (m_pPendingAdviseList && m_pPendingAdviseList->GetCount() > 0)
  67.     {
  68. PendingAdvise* pPendingAdvise = 
  69.     (PendingAdvise*) m_pPendingAdviseList->RemoveHead();
  70. delete pPendingAdvise;
  71.     }
  73.     HX_RELEASE(m_pAdviseSink);
  74.     HX_DELETE(m_pPendingAdviseList);
  75. }
  77. CHXAdviseSinkControl::CHXAdviseSinkControl()
  78.     : m_lRefCount(0) 
  79.     , m_pInterruptState(NULL)
  80. {
  81.     m_pCallback = new CHXGenericCallback((void*)this, (fGenericCBFunc)AdviseSinkCallback);
  82.     m_pCallback->AddRef();
  83. }
  85. CHXAdviseSinkControl::~CHXAdviseSinkControl()
  86. {
  87.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  88.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  89.     {
  90. PlayerAdviseSink* pPlayerAdviseSink = 
  91.     (PlayerAdviseSink*) (*lSinkerator);
  93.      HX_DELETE(pPlayerAdviseSink);
  94.     }
  95.     m_pSinkList.RemoveAll();
  97.     HX_RELEASE(m_pInterruptState);
  99.     if (m_pCallback && m_pScheduler)
  100.     {
  101.         m_pScheduler->Remove(m_pCallback->GetPendingCallback());
  102.         m_pCallback->CallbackCanceled();
  103.     }
  105.     HX_RELEASE(m_pCallback);
  106.     HX_RELEASE(m_pScheduler);
  107. }
  109. void
  110. CHXAdviseSinkControl::Init(IHXClientEngine* pEngine)
  111. {
  112.     pEngine->QueryInterface(IID_IHXInterruptState, 
  113. (void**) &m_pInterruptState);
  114.     
  115.     pEngine->QueryInterface(IID_IHXScheduler, (void**) &m_pScheduler);
  116. }
  118. HX_RESULT   
  119. CHXAdviseSinkControl::AddAdviseSink(IHXClientAdviseSink* pAdviseSink)
  120. {
  121.     IHXInterruptSafe* pInterruptSafe =NULL;
  122.     BOOL bInterruptSafe =FALSE;
  123.     pAdviseSink->QueryInterface(IID_IHXInterruptSafe,(void**) &pInterruptSafe);
  124.     if (pInterruptSafe)
  125.     {
  126. bInterruptSafe=pInterruptSafe->IsInterruptSafe();
  127. pInterruptSafe->Release();
  128.     }
  130.     PlayerAdviseSink* pPlayerAdviseSink = new PlayerAdviseSink(pAdviseSink, 
  131. bInterruptSafe);
  132.     m_pSinkList.AddTail(pPlayerAdviseSink);
  134.     return HXR_OK;
  135. }
  137. HX_RESULT   
  138. CHXAdviseSinkControl::RemoveAdviseSink(IHXClientAdviseSink* pAdviseSink)
  139. {
  140.     PlayerAdviseSink* pPlayerAdviseSink;
  141.     CHXSimpleList::Iterator lIterator = m_pSinkList.Begin();
  142.     for (; lIterator != m_pSinkList.End(); ++lIterator)
  143.     {
  144. pPlayerAdviseSink = (PlayerAdviseSink*) (*lIterator);
  145.      if (pPlayerAdviseSink->m_pAdviseSink == pAdviseSink)
  146.      {
  147.     LISTPOSITION pos = m_pSinkList.Find(pPlayerAdviseSink);
  148.     m_pSinkList.RemoveAt(pos);     
  149.     HX_DELETE(pPlayerAdviseSink);
  150.     return HXR_OK;
  151.      }
  152.     }
  154.     return HXR_FAIL;
  155. }
  159. //
  160. // This object is never interrupt safe
  161. // and thus cannot be called at interrupt time.
  162. //
  163. STDMETHODIMP_(BOOL) CHXAdviseSinkControl::IsInterruptSafe()
  164. {
  165. return FALSE;
  166. }
  168. // *** IUnknown methods ***
  170. /////////////////////////////////////////////////////////////////////////
  171. //  Method:
  172. // IUnknown::QueryInterface
  173. //  Purpose:
  174. // Implement this to export the interfaces supported by your 
  175. // object.
  176. //
  177. STDMETHODIMP CHXAdviseSinkControl::QueryInterface(REFIID riid, void** ppvObj)
  178. {
  179.     QInterfaceList qiList[] =
  180.         {
  181.             { GET_IIDHANDLE(IID_IHXClientAdviseSink), (IHXClientAdviseSink*)this },
  182.             { GET_IIDHANDLE(IID_IHXInterruptSafe), (IHXInterruptSafe*)this },
  183.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXClientAdviseSink*)this },
  184.         };
  185.     
  186.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  187. }
  189. /////////////////////////////////////////////////////////////////////////
  190. //  Method:
  191. // IUnknown::AddRef
  192. //  Purpose:
  193. // Everyone usually implements this the same... feel free to use
  194. // this implementation.
  195. //
  196. STDMETHODIMP_(ULONG32) CHXAdviseSinkControl::AddRef()
  197. {
  198.     return InterlockedIncrement(&m_lRefCount);
  199. }
  201. /////////////////////////////////////////////////////////////////////////
  202. //  Method:
  203. // IUnknown::Release
  204. //  Purpose:
  205. // Everyone usually implements this the same... feel free to use
  206. // this implementation.
  207. //
  208. STDMETHODIMP_(ULONG32) CHXAdviseSinkControl::Release()
  209. {
  210.     if (InterlockedDecrement(&m_lRefCount) > 0)
  211.     {
  212.         return m_lRefCount;
  213.     }
  215.     delete this;
  216.     return 0;
  217. }
  220. void
  221. CHXAdviseSinkControl::AddToPendingList(PlayerAdviseSink* pPlayerAdviseSink,
  222.        AdviseType type,
  223.        UINT32 ulArg1, 
  224.        UINT32 ulArg2, 
  225.        char*  pHostName)
  226. {
  227.     if (!pPlayerAdviseSink->m_pPendingAdviseList)
  228.     {
  229. pPlayerAdviseSink->m_pPendingAdviseList = new CHXSimpleList;
  230.     }
  232.     PendingAdvise* pPendingAdvise = new PendingAdvise;
  233.     pPendingAdvise->m_AdviseType = type;
  234.     pPendingAdvise->m_ulArg1 = ulArg1;
  235.     pPendingAdvise->m_ulArg2 = ulArg2;
  237.     if (pHostName)
  238.     {
  239. pPendingAdvise->m_pHostName = new char[strlen(pHostName) + 1];
  240. strcpy(pPendingAdvise->m_pHostName, pHostName); /* Flawfinder: ignore */
  241.     }
  243.     pPlayerAdviseSink->m_pPendingAdviseList->AddTail((void*) pPendingAdvise);
  245.     if (!m_pCallback->GetPendingCallback())
  246.     {
  247.         m_pCallback->CallbackScheduled(m_pScheduler->RelativeEnter(m_pCallback, 0));
  248.     }
  249. }
  251. void
  252. CHXAdviseSinkControl::ProcessAllRequests(void)
  253. {
  254.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  255.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  256.     {
  257. PlayerAdviseSink* pPlayerAdviseSink = 
  258.     (PlayerAdviseSink*) (*lSinkerator);
  259. ProcessPendingRequests(pPlayerAdviseSink);
  260.     }
  261. }
  263. void
  264. CHXAdviseSinkControl::ProcessPendingRequests(PlayerAdviseSink* 
  265. pPlayerAdviseSink)
  266. {
  267.     while (pPlayerAdviseSink->m_pPendingAdviseList && 
  268.    pPlayerAdviseSink->m_pPendingAdviseList->GetCount() > 0)
  269.     {
  270. PendingAdvise* pPendingAdvise = (PendingAdvise*) 
  271. pPlayerAdviseSink->m_pPendingAdviseList->RemoveHead();
  272. switch(pPendingAdvise->m_AdviseType)
  273. {
  274.     case ONPOSLENGTH:
  275.      pPlayerAdviseSink->m_pAdviseSink->OnPosLength(
  276.     pPendingAdvise->m_ulArg1, 
  277.     pPendingAdvise->m_ulArg2);
  278. break;
  279.     case ONPRESENTATIONOPENED:
  280.      pPlayerAdviseSink->m_pAdviseSink->OnPresentationOpened();
  281. break;
  282.     case ONPRESENTATIONCLOSED:
  283.      pPlayerAdviseSink->m_pAdviseSink->OnPresentationClosed();
  284. break;
  285.     case ONSTATISTICSCHANGED:
  286.      pPlayerAdviseSink->m_pAdviseSink->OnStatisticsChanged();
  287. break;
  288.     case ONPRESEEK:
  289.      pPlayerAdviseSink->m_pAdviseSink->OnPreSeek(
  290.     pPendingAdvise->m_ulArg1, 
  291.     pPendingAdvise->m_ulArg2);
  292. break;
  293.     case ONPOSTSEEK:
  294.      pPlayerAdviseSink->m_pAdviseSink->OnPostSeek(
  295.     pPendingAdvise->m_ulArg1, 
  296.     pPendingAdvise->m_ulArg2);
  297. break;
  298.     case ONSTOP:
  299.      pPlayerAdviseSink->m_pAdviseSink->OnStop();
  300. break;
  301.     case ONPAUSE:
  302.          pPlayerAdviseSink->m_pAdviseSink->OnPause(
  303. pPendingAdvise->m_ulArg1);
  304. break;
  305.     case ONBEGIN:
  306.          pPlayerAdviseSink->m_pAdviseSink->OnBegin(
  307. pPendingAdvise->m_ulArg1);
  308. break;
  309.     case ONBUFFERING:
  310.      pPlayerAdviseSink->m_pAdviseSink->OnBuffering(
  311. pPendingAdvise->m_ulArg1, 
  312.        (UINT16) pPendingAdvise->m_ulArg2);
  313. break;
  314.     case ONCONTACTING:
  315.      pPlayerAdviseSink->m_pAdviseSink->OnContacting(
  316.      pPendingAdvise->m_pHostName);
  317. break;
  318.     default:
  319. HX_ASSERT(FALSE);
  320. break;
  321. }
  323. delete pPendingAdvise;
  324.     }
  325. }
  327. /*
  328.  * IHXClientAdviseSink methods
  329.  */
  331. /************************************************************************
  332.  * Method:
  333.  *     IHXClientAdviseSink::OnPosLength
  334.  * Purpose:
  335.  *     Called to advise the client that the position or length of the
  336.  *     current playback context has changed.
  337.  */
  338. STDMETHODIMP
  339. CHXAdviseSinkControl::OnPosLength(UINT32   ulPosition,
  340.    UINT32   ulLength)
  341. {
  342.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  343.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  344.     {
  345. PlayerAdviseSink* pPlayerAdviseSink = 
  346.     (PlayerAdviseSink*) (*lSinkerator);
  347. if (!m_pInterruptState->AtInterruptTime() || 
  348.     pPlayerAdviseSink->m_bInterruptSafe)
  349. {
  350.     ProcessPendingRequests(pPlayerAdviseSink);
  351.          pPlayerAdviseSink->m_pAdviseSink->OnPosLength(ulPosition, 
  352.   ulLength);
  353. }
  354. else
  355. {
  356.     AddToPendingList(pPlayerAdviseSink, ONPOSLENGTH, 
  357.      ulPosition, ulLength);
  358. }
  359.     }
  361.     return HXR_OK;
  362. }
  364. /************************************************************************
  365.  * Method:
  366.  *     IHXClientAdviseSink::OnPresentationOpened
  367.  * Purpose:
  368.  *     Called to advise the client a presentation has been opened.
  369.  */
  370. STDMETHODIMP CHXAdviseSinkControl::OnPresentationOpened()
  371. {
  372.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  373.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  374.     {
  375. PlayerAdviseSink* pPlayerAdviseSink = 
  376.     (PlayerAdviseSink*) (*lSinkerator);
  377. if (!m_pInterruptState->AtInterruptTime() || 
  378.     pPlayerAdviseSink->m_bInterruptSafe)
  379. {
  380.     ProcessPendingRequests(pPlayerAdviseSink);
  381.          pPlayerAdviseSink->m_pAdviseSink->OnPresentationOpened();
  382. }
  383. else
  384. {
  385.     AddToPendingList(pPlayerAdviseSink, ONPRESENTATIONOPENED);
  386. }
  387.     }
  389.     return HXR_OK;
  390. }
  393. /************************************************************************
  394.  * Method:
  395.  *     IHXClientAdviseSink::OnPresentationClosed
  396.  * Purpose:
  397.  *     Called to advise the client a presentation has been closed.
  398.  */
  399. STDMETHODIMP CHXAdviseSinkControl::OnPresentationClosed()
  400. {
  401.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  402.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  403.     {
  404. PlayerAdviseSink* pPlayerAdviseSink = 
  405.     (PlayerAdviseSink*) (*lSinkerator);
  406. if (!m_pInterruptState->AtInterruptTime() || 
  407.     pPlayerAdviseSink->m_bInterruptSafe)
  408. {
  409.     ProcessPendingRequests(pPlayerAdviseSink);
  410.          pPlayerAdviseSink->m_pAdviseSink->OnPresentationClosed();
  411. }
  412. else
  413. {
  414.     AddToPendingList(pPlayerAdviseSink, ONPRESENTATIONCLOSED);
  415. }
  416.     }
  418.     return HXR_OK;
  419. }
  421. /************************************************************************
  422.  * Method:
  423.  *     IHXClientAdviseSink::OnStatisticsChanged
  424.  * Purpose:
  425.  *     Called to advise the client that the presentation statistics
  426.  *     have changed. 
  427.  */
  428. STDMETHODIMP CHXAdviseSinkControl::OnStatisticsChanged(void)
  429. {
  430.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  431.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  432.     {
  433. PlayerAdviseSink* pPlayerAdviseSink = 
  434.     (PlayerAdviseSink*) (*lSinkerator);
  435. if (!m_pInterruptState->AtInterruptTime() || 
  436.     pPlayerAdviseSink->m_bInterruptSafe)
  437. {
  438.     ProcessPendingRequests(pPlayerAdviseSink);
  439.          pPlayerAdviseSink->m_pAdviseSink->OnStatisticsChanged();
  440. }
  441. else
  442. {
  443.     AddToPendingList(pPlayerAdviseSink, ONSTATISTICSCHANGED);
  444. }
  445.     }
  447.     return HXR_OK;
  448. }
  450. /************************************************************************
  451.  * Method:
  452.  *     IHXClientAdviseSink::OnPreSeek
  453.  * Purpose:
  454.  *     Called by client engine to inform the client that a seek is
  455.  *     about to occur. The render is informed the last time for the 
  456.  *     stream's time line before the seek, as well as the first new
  457.  *     time for the stream's time line after the seek will be completed.
  458.  *
  459.  */
  460. STDMETHODIMP CHXAdviseSinkControl::OnPreSeek( ULONG32 ulOldTime,
  461. ULONG32 ulNewTime)
  462. {
  463.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  464.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  465.     {
  466. PlayerAdviseSink* pPlayerAdviseSink = 
  467.     (PlayerAdviseSink*) (*lSinkerator);
  468. if (!m_pInterruptState->AtInterruptTime() || 
  469.     pPlayerAdviseSink->m_bInterruptSafe)
  470. {
  471.     ProcessPendingRequests(pPlayerAdviseSink);
  472.          pPlayerAdviseSink->m_pAdviseSink->OnPreSeek(ulOldTime, 
  473. ulNewTime);
  474. }
  475. else
  476. {
  477.     AddToPendingList(pPlayerAdviseSink, ONPRESEEK, 
  478.      ulOldTime, ulNewTime);
  479. }
  480.     }
  482.     return HXR_OK;
  483. }
  486. /************************************************************************
  487.  * Method:
  488.  *     IHXClientAdviseSink::OnPostSeek
  489.  * Purpose:
  490.  *     Called by client engine to inform the client that a seek has
  491.  *     just occured. The render is informed the last time for the 
  492.  *     stream's time line before the seek, as well as the first new
  493.  *     time for the stream's time line after the seek.
  494.  *
  495.  */
  496. STDMETHODIMP CHXAdviseSinkControl::OnPostSeek( ULONG32 ulOldTime,
  497. ULONG32 ulNewTime)
  498. {
  499.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  500.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  501.     {
  502. PlayerAdviseSink* pPlayerAdviseSink = 
  503.     (PlayerAdviseSink*) (*lSinkerator);
  504. if (!m_pInterruptState->AtInterruptTime() || 
  505.     pPlayerAdviseSink->m_bInterruptSafe)
  506. {
  507.     ProcessPendingRequests(pPlayerAdviseSink);
  508.          pPlayerAdviseSink->m_pAdviseSink->OnPostSeek(ulOldTime, 
  509.  ulNewTime);
  510. }
  511. else
  512. {
  513.     AddToPendingList(pPlayerAdviseSink, ONPOSTSEEK, 
  514.      ulOldTime, ulNewTime);
  515. }
  516.     }
  518.     return HXR_OK;
  519. }
  522. /************************************************************************
  523.  * Method:
  524.  *     IHXClientAdviseSink::OnStop
  525.  * Purpose:
  526.  *     Called by client engine to inform the client that a stop has
  527.  *     just occured. 
  528.  *
  529.  */
  530. STDMETHODIMP CHXAdviseSinkControl::OnStop(void)
  531. {
  532.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  533.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  534.     {
  535. PlayerAdviseSink* pPlayerAdviseSink = 
  536.     (PlayerAdviseSink*) (*lSinkerator);
  537. if (!m_pInterruptState->AtInterruptTime() || 
  538.     pPlayerAdviseSink->m_bInterruptSafe)
  539. {
  540.     ProcessPendingRequests(pPlayerAdviseSink);
  541.          pPlayerAdviseSink->m_pAdviseSink->OnStop();
  542. }
  543. else
  544. {
  545.     AddToPendingList(pPlayerAdviseSink, ONSTOP);
  546. }
  547.     }
  549.     return HXR_OK;
  550. }
  552. /************************************************************************
  553.  * Method:
  554.  *     IHXClientAdviseSink::OnPause
  555.  * Purpose:
  556.  *     Called by client engine to inform the client that a pause has
  557.  *     just occured. The render is informed the last time for the 
  558.  *     stream's time line before the pause.
  559.  *
  560.  */
  561. STDMETHODIMP CHXAdviseSinkControl::OnPause(ULONG32 ulTime)
  562. {
  563.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  564.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  565.     {
  566. PlayerAdviseSink* pPlayerAdviseSink = 
  567.     (PlayerAdviseSink*) (*lSinkerator);
  568. if (!m_pInterruptState->AtInterruptTime() || 
  569.     pPlayerAdviseSink->m_bInterruptSafe)
  570. {
  571.     ProcessPendingRequests(pPlayerAdviseSink);
  572.          pPlayerAdviseSink->m_pAdviseSink->OnPause(ulTime);
  573. }
  574. else
  575. {
  576.     AddToPendingList(pPlayerAdviseSink, ONPAUSE, ulTime);
  577. }
  578.     }
  580.     return HXR_OK;
  581. }
  584. /************************************************************************
  585.  * Method:
  586.  *     IHXClientAdviseSink::OnBegin
  587.  * Purpose:
  588.  *     Called by client engine to inform the client that a begin or
  589.  *     resume has just occured. The render is informed the first time 
  590.  *     for the stream's time line after the resume.
  591.  *
  592.  */
  593. STDMETHODIMP CHXAdviseSinkControl::OnBegin(ULONG32 ulTime)
  594. {
  595.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  596.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  597.     {
  598. PlayerAdviseSink* pPlayerAdviseSink = 
  599.     (PlayerAdviseSink*) (*lSinkerator);
  600. if (!m_pInterruptState->AtInterruptTime() || 
  601.     pPlayerAdviseSink->m_bInterruptSafe)
  602. {
  603.     ProcessPendingRequests(pPlayerAdviseSink);
  604.          pPlayerAdviseSink->m_pAdviseSink->OnBegin(ulTime);
  605. }
  606. else
  607. {
  608.     AddToPendingList(pPlayerAdviseSink, ONBEGIN, ulTime);
  609. }
  610.     }
  612.     return HXR_OK;
  613. }
  616. /************************************************************************
  617.  * Method:
  618.  *     IHXClientAdviseSink::OnBuffering
  619.  * Purpose:
  620.  *     Called by client engine to inform the client that buffering
  621.  *     of data is occuring. The render is informed of the reason for
  622.  *     the buffering (start-up of stream, seek has occured, network
  623.  *     congestion, etc.), as well as percentage complete of the 
  624.  *     buffering process.
  625.  *
  626.  */
  627. STDMETHODIMP CHXAdviseSinkControl::OnBuffering(ULONG32 ulFlags,
  628. UINT16 unPercentComplete)
  629. {
  630.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  631.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  632.     {
  633. PlayerAdviseSink* pPlayerAdviseSink = 
  634.     (PlayerAdviseSink*) (*lSinkerator);
  635. if (!m_pInterruptState->AtInterruptTime() || 
  636.     pPlayerAdviseSink->m_bInterruptSafe)
  637. {
  638.     ProcessPendingRequests(pPlayerAdviseSink);
  639.          pPlayerAdviseSink->m_pAdviseSink->OnBuffering(ulFlags, 
  640.   unPercentComplete);
  641. }
  642. else
  643. {
  644.     AddToPendingList(pPlayerAdviseSink, ONBUFFERING, 
  645.      ulFlags, (UINT32) unPercentComplete);
  646. }
  647.     }
  649.     return HXR_OK;
  650. }
  653. /************************************************************************
  654.  * Method:
  655.  *     IHXClientAdviseSink::OnContacting
  656.  * Purpose:
  657.  *     Called by client engine to inform the client is contacting
  658.  *     hosts(s).
  659.  *
  660.  */
  661. STDMETHODIMP CHXAdviseSinkControl::OnContacting(const char* pHostName)
  662. {
  663.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  664.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  665.     {
  666. PlayerAdviseSink* pPlayerAdviseSink = 
  667.     (PlayerAdviseSink*) (*lSinkerator);
  668. if (!m_pInterruptState->AtInterruptTime() || 
  669.     pPlayerAdviseSink->m_bInterruptSafe)
  670. {
  671.     ProcessPendingRequests(pPlayerAdviseSink);
  672.          pPlayerAdviseSink->m_pAdviseSink->OnContacting(pHostName);
  673. }
  674. else
  675. {
  676.     AddToPendingList(pPlayerAdviseSink, ONCONTACTING, 
  677.      0, 0, (char*) pHostName);
  678. }
  679.     }
  681.     return HXR_OK;
  682. }
  685. void CHXAdviseSinkControl::AdviseSinkCallback(void* pParam)
  686. {
  687.     CHXAdviseSinkControl* pObj = (CHXAdviseSinkControl*)pParam;
  688.     
  689.     if (pObj)
  690.     {
  691.         pObj->ProcessAllRequests();
  692.     }
  693. }    
  696. /************************************************************************
  698. /* CHXErrorSinkControl */
  700. CHXErrorSinkControl::CHXErrorSinkControl() :
  701.      m_lRefCount (0)
  702.     ,m_pPendingErrorList(NULL) 
  703.     ,m_pInterruptState(NULL)
  704.     ,m_pScheduler(NULL)
  705.     ,m_pErrorCallback(NULL)
  706. {
  707.     m_pErrorCallback = new CHXGenericCallback((void*)this, (fGenericCBFunc)ErrorCallback);
  708.     m_pErrorCallback->AddRef();
  709. }
  711. CHXErrorSinkControl::~CHXErrorSinkControl()
  712. {
  713.     Close();
  714. }
  716. STDMETHODIMP
  717. CHXErrorSinkControl::AddErrorSink (
  718. IHXErrorSink* pErrorSink,
  719.                                 const UINT8     unLowSeverity,
  720.                                 const UINT8     unHighSeverity)
  721. {
  722.     if (pErrorSink)
  723.     {
  724.      PlayerErrorSink* pPlayerErrorSink = new PlayerErrorSink(pErrorSink, unLowSeverity, unHighSeverity);
  725.      m_pSinkList.AddTail(pPlayerErrorSink);
  726.      pErrorSink->AddRef();
  727.     
  728.     }
  729.     return HXR_OK;
  730. }
  732. STDMETHODIMP
  733. CHXErrorSinkControl::RemoveErrorSink(IHXErrorSink* pErrorSink)
  734. {
  735.     PlayerErrorSink* pPlayerErrorSink;
  736.     CHXSimpleList::Iterator lIterator = m_pSinkList.Begin();
  737.     for (; lIterator != m_pSinkList.End(); ++lIterator)
  738.     {
  739. pPlayerErrorSink = (PlayerErrorSink *) (*lIterator);
  740.      if (pPlayerErrorSink->m_pErrorSink == pErrorSink)
  741.      {
  742.     HX_RELEASE (pErrorSink);
  743.     
  744.     LISTPOSITION pos = m_pSinkList.Find(pPlayerErrorSink);
  745.     m_pSinkList.RemoveAt(pos);     
  746.     delete pPlayerErrorSink;
  747.     return HXR_OK;
  748.      }
  749.     }
  750.     return HXR_FAIL;
  751. }
  753. STDMETHODIMP 
  754. CHXErrorSinkControl::QueryInterface(REFIID riid, void** ppvObj)
  755. {
  756.     QInterfaceList qiList[] =
  757.         {
  758.             { GET_IIDHANDLE(IID_IHXErrorSinkControl), (IHXErrorSinkControl*)this },
  759.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXErrorSinkControl*)this },
  760.         };
  761.     
  762.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  763. }
  765. STDMETHODIMP_ (ULONG32) 
  766. CHXErrorSinkControl::AddRef()
  767. {
  768.     return InterlockedIncrement(&m_lRefCount);
  769. }
  771. STDMETHODIMP_ (ULONG32) 
  772. CHXErrorSinkControl::Release()
  773. {
  774.     if (InterlockedDecrement(&m_lRefCount) > 0)
  775.     {
  776. return m_lRefCount;
  777.     }
  779.     delete this;
  780.     return 0;
  781. }
  783. void 
  784. CHXErrorSinkControl::GetSeverityRange(IHXErrorSink* pErrorSink, 
  785. UINT8& unLowSeverity, 
  786.      UINT8& unHighSeverity)
  787. {
  788.     PlayerErrorSink* pPlayerErrorSink;
  789.     CHXSimpleList::Iterator lIterator = m_pSinkList.Begin();
  790.     for (; lIterator != m_pSinkList.End(); ++lIterator)
  791.     {
  792. pPlayerErrorSink = (PlayerErrorSink *) (*lIterator);
  793.      if (pPlayerErrorSink->m_pErrorSink == pErrorSink)
  794.      {
  795.     unLowSeverity = pPlayerErrorSink->m_unLowSeverity;
  796.     unHighSeverity = pPlayerErrorSink->m_unHighSeverity;
  797.     break;
  798.      }
  799.     }
  800. }
  802. void
  803. CHXErrorSinkControl::Init(IHXClientEngine* pEngine)
  804. {
  805.     pEngine->QueryInterface(IID_IHXInterruptState, 
  806. (void**) &m_pInterruptState);
  807.     
  808.     pEngine->QueryInterface(IID_IHXScheduler, (void**) &m_pScheduler);
  809. }
  811. void 
  812. CHXErrorSinkControl::Close()
  813. {
  814.     PlayerErrorSink* pPlayerErrorSink;
  815.     CHXSimpleList::Iterator lIterator = m_pSinkList.Begin();
  816.     for (; lIterator != m_pSinkList.End(); ++lIterator)
  817.     {
  818. pPlayerErrorSink = (PlayerErrorSink *) (*lIterator);
  819. HX_RELEASE (pPlayerErrorSink->m_pErrorSink);
  820. delete pPlayerErrorSink;
  821.     }
  823.     m_pSinkList.RemoveAll();
  825.     while (m_pPendingErrorList && m_pPendingErrorList->GetCount() > 0)
  826.     {
  827. ErrorReport* pErrorReport = 
  828.     (ErrorReport*) m_pPendingErrorList->RemoveHead();
  829. delete pErrorReport;
  830.     }
  832.     
  833.     if (m_pErrorCallback)
  834.     {
  835.         m_pScheduler->Remove(m_pErrorCallback->GetPendingCallback());
  836.         m_pErrorCallback->CallbackCanceled();
  837.         HX_RELEASE(m_pErrorCallback);
  838.     }
  840.     HX_DELETE(m_pPendingErrorList);
  841.     HX_RELEASE(m_pInterruptState);
  842.     HX_RELEASE(m_pScheduler);
  843. }
  845. HX_RESULT 
  846. CHXErrorSinkControl::ErrorOccurred( const UINT8 unSeverity,  
  847.     const ULONG32 ulHXCode,
  848.     const ULONG32 ulUserCode,
  849.     const char* pUserString,
  850.     const char* pMoreInfoURL)
  851. {
  852.     if (m_pInterruptState->AtInterruptTime())
  853.     {
  854. if (!m_pPendingErrorList)
  855. {
  856.     m_pPendingErrorList = new CHXSimpleList;
  857. }
  859. ErrorReport* pErrorReport = new ErrorReport;
  860. pErrorReport->m_unSeverity = unSeverity;
  861. pErrorReport->m_ulHXCode = ulHXCode;
  862. pErrorReport->m_ulUserCode = ulUserCode;
  864. if (pUserString && *pUserString)
  865. {
  866.     pErrorReport->m_pUserString = new char[strlen(pUserString) + 1];
  867.     ::strcpy(pErrorReport->m_pUserString, pUserString); /* Flawfinder: ignore */
  868. }
  870. if (pMoreInfoURL && *pMoreInfoURL)
  871. {
  872.     pErrorReport->m_pMoreInfoURL = new char[strlen(pMoreInfoURL) + 1];
  873.     ::strcpy(pErrorReport->m_pMoreInfoURL, pMoreInfoURL); /* Flawfinder: ignore */
  874. }
  876. m_pPendingErrorList->AddTail((void*) pErrorReport);
  878.         if (!m_pErrorCallback->GetPendingCallback())
  879. {
  880.             m_pErrorCallback->CallbackScheduled(
  881.              m_pScheduler->RelativeEnter(m_pErrorCallback, 0));
  882. }
  884. return HXR_OK;
  885.     }
  887.     ReportPendingErrors();
  889.     CallReport(unSeverity,
  890.        ulHXCode,
  891.        ulUserCode,
  892.        pUserString,
  893.        pMoreInfoURL);
  895.     return HXR_OK;
  896. }
  898. void
  899. CHXErrorSinkControl::ReportPendingErrors()
  900. {
  901.     if (m_pErrorCallback)
  902.     {
  903.         m_pScheduler->Remove(m_pErrorCallback->GetPendingCallback());
  904.         m_pErrorCallback->CallbackCanceled();
  905.     }
  907.     while (m_pPendingErrorList && m_pPendingErrorList->GetCount() > 0)
  908.     {
  909. ErrorReport* pErrorReport = 
  910.     (ErrorReport*) m_pPendingErrorList->RemoveHead();
  911. CallReport(pErrorReport->m_unSeverity,
  912.    pErrorReport->m_ulHXCode,
  913.    pErrorReport->m_ulUserCode,
  914.    pErrorReport->m_pUserString,
  915.    pErrorReport->m_pMoreInfoURL);
  916. delete pErrorReport;
  917.     }
  918. }
  920. HX_RESULT
  921. CHXErrorSinkControl::CallReport
  922. (
  923.     const UINT8 unSeverity,  
  924.     HX_RESULT ulHXCode,
  925.     const ULONG32 ulUserCode,
  926.     const char* pUserString,
  927.     const char* pMoreInfoURL
  928. )
  929. {
  930.     CHXSimpleList::Iterator ndxSink;
  931.     for (ndxSink = m_pSinkList.Begin(); 
  932.  ndxSink != m_pSinkList.End(); ++ndxSink)
  933.     {
  934. PlayerErrorSink* pPlayerErrorSink =
  935. (PlayerErrorSink*) (*ndxSink);
  937. // error-reporting based on its severity   
  938. if (unSeverity >= pPlayerErrorSink->m_unLowSeverity &&
  939.     unSeverity <= pPlayerErrorSink->m_unHighSeverity)
  940. //     unSeverity <= pPlayerErrorSink->m_unHighSeverity && !m_pAltURLs->GetCount())
  941. {
  942.     pPlayerErrorSink->m_pErrorSink->ErrorOccurred(unSeverity, ulHXCode,
  943. ulUserCode, pUserString, pMoreInfoURL);
  944. }
  945.     }
  947.     return HXR_OK;
  948. }
  951. void CHXErrorSinkControl::ErrorCallback(void* pParam)
  952. {
  953.     CHXErrorSinkControl* pObj = (CHXErrorSinkControl*)pParam;
  955.     if (pObj)
  956.     {
  957.         pObj->ReportPendingErrors();
  958.     }
  959. }