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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
sinkctl.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：27k
源码类别：

Symbian

开发平台：

Visual C++

sinkctl.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: sinkctl.cpp,v 1.6.8.1 2004/07/09 02:05:58 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #include "hxcom.h"
  51. #include "hxtypes.h"
  52. #include "hxclsnk.h"
  53. #include "hxengin.h"
  54. #include "hxcore.h"
  55. #include "hxengin.h"
  56. #include "hxsched.h"
  57. #include "hxerror.h"
  58. #include "hxslist.h"
  59. #include "hxcbobj.h"
  60. #include "sinkctl.h"
  62. #include "hxheap.h"
  63. #ifdef _DEBUG
  64. #undef HX_THIS_FILE
  65. static const char HX_THIS_FILE[] = __FILE__;
  66. #endif
  68. CHXAdviseSinkControl::PlayerAdviseSink::PlayerAdviseSink(
  69.     IHXClientAdviseSink* pAdviseSink,
  70.     BOOL bInterruptSafe)
  71. {
  72.     m_pAdviseSink     = pAdviseSink;
  73.     m_pAdviseSink->AddRef();
  74.     m_bInterruptSafe     = bInterruptSafe;
  75.     m_pPendingAdviseList    = NULL;
  76. }
  78. CHXAdviseSinkControl::PlayerAdviseSink::~PlayerAdviseSink()
  79. {
  80.     while (m_pPendingAdviseList && m_pPendingAdviseList->GetCount() > 0)
  81.     {
  82. PendingAdvise* pPendingAdvise = 
  83.     (PendingAdvise*) m_pPendingAdviseList->RemoveHead();
  84. delete pPendingAdvise;
  85.     }
  87.     HX_RELEASE(m_pAdviseSink);
  88.     HX_DELETE(m_pPendingAdviseList);
  89. }
  91. CHXAdviseSinkControl::CHXAdviseSinkControl()
  92.     : m_lRefCount(0) 
  93.     , m_pInterruptState(NULL)
  94. {
  95.     m_pCallback = new CHXGenericCallback((void*)this, (fGenericCBFunc)AdviseSinkCallback);
  96.     m_pCallback->AddRef();
  97. }
  99. CHXAdviseSinkControl::~CHXAdviseSinkControl()
  100. {
  101.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  102.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  103.     {
  104. PlayerAdviseSink* pPlayerAdviseSink = 
  105.     (PlayerAdviseSink*) (*lSinkerator);
  107.      HX_DELETE(pPlayerAdviseSink);
  108.     }
  109.     m_pSinkList.RemoveAll();
  111.     HX_RELEASE(m_pInterruptState);
  113.     if (m_pCallback && m_pScheduler)
  114.     {
  115.         m_pScheduler->Remove(m_pCallback->GetPendingCallback());
  116.         m_pCallback->CallbackCanceled();
  117.     }
  119.     HX_RELEASE(m_pCallback);
  120.     HX_RELEASE(m_pScheduler);
  121. }
  123. void
  124. CHXAdviseSinkControl::Init(IHXClientEngine* pEngine)
  125. {
  126.     pEngine->QueryInterface(IID_IHXInterruptState, 
  127. (void**) &m_pInterruptState);
  128.     
  129.     pEngine->QueryInterface(IID_IHXScheduler, (void**) &m_pScheduler);
  130. }
  132. HX_RESULT   
  133. CHXAdviseSinkControl::AddAdviseSink(IHXClientAdviseSink* pAdviseSink)
  134. {
  135.     IHXInterruptSafe* pInterruptSafe =NULL;
  136.     BOOL bInterruptSafe =FALSE;
  137.     pAdviseSink->QueryInterface(IID_IHXInterruptSafe,(void**) &pInterruptSafe);
  138.     if (pInterruptSafe)
  139.     {
  140. bInterruptSafe=pInterruptSafe->IsInterruptSafe();
  141. pInterruptSafe->Release();
  142.     }
  144.     PlayerAdviseSink* pPlayerAdviseSink = new PlayerAdviseSink(pAdviseSink, 
  145. bInterruptSafe);
  146.     m_pSinkList.AddTail(pPlayerAdviseSink);
  148.     return HXR_OK;
  149. }
  151. HX_RESULT   
  152. CHXAdviseSinkControl::RemoveAdviseSink(IHXClientAdviseSink* pAdviseSink)
  153. {
  154.     PlayerAdviseSink* pPlayerAdviseSink;
  155.     CHXSimpleList::Iterator lIterator = m_pSinkList.Begin();
  156.     for (; lIterator != m_pSinkList.End(); ++lIterator)
  157.     {
  158. pPlayerAdviseSink = (PlayerAdviseSink*) (*lIterator);
  159.      if (pPlayerAdviseSink->m_pAdviseSink == pAdviseSink)
  160.      {
  161.     LISTPOSITION pos = m_pSinkList.Find(pPlayerAdviseSink);
  162.     m_pSinkList.RemoveAt(pos);     
  163.     HX_DELETE(pPlayerAdviseSink);
  164.     return HXR_OK;
  165.      }
  166.     }
  168.     return HXR_FAIL;
  169. }
  173. //
  174. // This object is never interrupt safe
  175. // and thus cannot be called at interrupt time.
  176. //
  177. STDMETHODIMP_(BOOL) CHXAdviseSinkControl::IsInterruptSafe()
  178. {
  179. return FALSE;
  180. }
  182. // *** IUnknown methods ***
  184. /////////////////////////////////////////////////////////////////////////
  185. //  Method:
  186. // IUnknown::QueryInterface
  187. //  Purpose:
  188. // Implement this to export the interfaces supported by your 
  189. // object.
  190. //
  191. STDMETHODIMP CHXAdviseSinkControl::QueryInterface(REFIID riid, void** ppvObj)
  192. {
  193.     QInterfaceList qiList[] =
  194.         {
  195.             { GET_IIDHANDLE(IID_IHXClientAdviseSink), (IHXClientAdviseSink*)this },
  196.             { GET_IIDHANDLE(IID_IHXInterruptSafe), (IHXInterruptSafe*)this },
  197.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXClientAdviseSink*)this },
  198.         };
  199.     
  200.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  201. }
  203. /////////////////////////////////////////////////////////////////////////
  204. //  Method:
  205. // IUnknown::AddRef
  206. //  Purpose:
  207. // Everyone usually implements this the same... feel free to use
  208. // this implementation.
  209. //
  210. STDMETHODIMP_(ULONG32) CHXAdviseSinkControl::AddRef()
  211. {
  212.     return InterlockedIncrement(&m_lRefCount);
  213. }
  215. /////////////////////////////////////////////////////////////////////////
  216. //  Method:
  217. // IUnknown::Release
  218. //  Purpose:
  219. // Everyone usually implements this the same... feel free to use
  220. // this implementation.
  221. //
  222. STDMETHODIMP_(ULONG32) CHXAdviseSinkControl::Release()
  223. {
  224.     if (InterlockedDecrement(&m_lRefCount) > 0)
  225.     {
  226.         return m_lRefCount;
  227.     }
  229.     delete this;
  230.     return 0;
  231. }
  234. void
  235. CHXAdviseSinkControl::AddToPendingList(PlayerAdviseSink* pPlayerAdviseSink,
  236.        AdviseType type,
  237.        UINT32 ulArg1, 
  238.        UINT32 ulArg2, 
  239.        char*  pHostName)
  240. {
  241.     if (!pPlayerAdviseSink->m_pPendingAdviseList)
  242.     {
  243. pPlayerAdviseSink->m_pPendingAdviseList = new CHXSimpleList;
  244.     }
  246.     PendingAdvise* pPendingAdvise = new PendingAdvise;
  247.     pPendingAdvise->m_AdviseType = type;
  248.     pPendingAdvise->m_ulArg1 = ulArg1;
  249.     pPendingAdvise->m_ulArg2 = ulArg2;
  251.     if (pHostName)
  252.     {
  253. pPendingAdvise->m_pHostName = new char[strlen(pHostName) + 1];
  254. strcpy(pPendingAdvise->m_pHostName, pHostName); /* Flawfinder: ignore */
  255.     }
  257.     pPlayerAdviseSink->m_pPendingAdviseList->AddTail((void*) pPendingAdvise);
  259.     if (!m_pCallback->GetPendingCallback())
  260.     {
  261.         m_pCallback->CallbackScheduled(m_pScheduler->RelativeEnter(m_pCallback, 0));
  262.     }
  263. }
  265. void
  266. CHXAdviseSinkControl::ProcessAllRequests(void)
  267. {
  268.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  269.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  270.     {
  271. PlayerAdviseSink* pPlayerAdviseSink = 
  272.     (PlayerAdviseSink*) (*lSinkerator);
  273. ProcessPendingRequests(pPlayerAdviseSink);
  274.     }
  275. }
  277. void
  278. CHXAdviseSinkControl::ProcessPendingRequests(PlayerAdviseSink* 
  279. pPlayerAdviseSink)
  280. {
  281.     while (pPlayerAdviseSink->m_pPendingAdviseList && 
  282.    pPlayerAdviseSink->m_pPendingAdviseList->GetCount() > 0)
  283.     {
  284. PendingAdvise* pPendingAdvise = (PendingAdvise*) 
  285. pPlayerAdviseSink->m_pPendingAdviseList->RemoveHead();
  286. switch(pPendingAdvise->m_AdviseType)
  287. {
  288.     case ONPOSLENGTH:
  289.      pPlayerAdviseSink->m_pAdviseSink->OnPosLength(
  290.     pPendingAdvise->m_ulArg1, 
  291.     pPendingAdvise->m_ulArg2);
  292. break;
  293.     case ONPRESENTATIONOPENED:
  294.      pPlayerAdviseSink->m_pAdviseSink->OnPresentationOpened();
  295. break;
  296.     case ONPRESENTATIONCLOSED:
  297.      pPlayerAdviseSink->m_pAdviseSink->OnPresentationClosed();
  298. break;
  299.     case ONSTATISTICSCHANGED:
  300.      pPlayerAdviseSink->m_pAdviseSink->OnStatisticsChanged();
  301. break;
  302.     case ONPRESEEK:
  303.      pPlayerAdviseSink->m_pAdviseSink->OnPreSeek(
  304.     pPendingAdvise->m_ulArg1, 
  305.     pPendingAdvise->m_ulArg2);
  306. break;
  307.     case ONPOSTSEEK:
  308.      pPlayerAdviseSink->m_pAdviseSink->OnPostSeek(
  309.     pPendingAdvise->m_ulArg1, 
  310.     pPendingAdvise->m_ulArg2);
  311. break;
  312.     case ONSTOP:
  313.      pPlayerAdviseSink->m_pAdviseSink->OnStop();
  314. break;
  315.     case ONPAUSE:
  316.          pPlayerAdviseSink->m_pAdviseSink->OnPause(
  317. pPendingAdvise->m_ulArg1);
  318. break;
  319.     case ONBEGIN:
  320.          pPlayerAdviseSink->m_pAdviseSink->OnBegin(
  321. pPendingAdvise->m_ulArg1);
  322. break;
  323.     case ONBUFFERING:
  324.      pPlayerAdviseSink->m_pAdviseSink->OnBuffering(
  325. pPendingAdvise->m_ulArg1, 
  326.        (UINT16) pPendingAdvise->m_ulArg2);
  327. break;
  328.     case ONCONTACTING:
  329.      pPlayerAdviseSink->m_pAdviseSink->OnContacting(
  330.      pPendingAdvise->m_pHostName);
  331. break;
  332.     default:
  333. HX_ASSERT(FALSE);
  334. break;
  335. }
  337. delete pPendingAdvise;
  338.     }
  339. }
  341. /*
  342.  * IHXClientAdviseSink methods
  343.  */
  345. /************************************************************************
  346.  * Method:
  347.  *     IHXClientAdviseSink::OnPosLength
  348.  * Purpose:
  349.  *     Called to advise the client that the position or length of the
  350.  *     current playback context has changed.
  351.  */
  352. STDMETHODIMP
  353. CHXAdviseSinkControl::OnPosLength(UINT32   ulPosition,
  354.    UINT32   ulLength)
  355. {
  356.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  357.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  358.     {
  359. PlayerAdviseSink* pPlayerAdviseSink = 
  360.     (PlayerAdviseSink*) (*lSinkerator);
  361. if (!m_pInterruptState->AtInterruptTime() || 
  362.     pPlayerAdviseSink->m_bInterruptSafe)
  363. {
  364.     ProcessPendingRequests(pPlayerAdviseSink);
  365.          pPlayerAdviseSink->m_pAdviseSink->OnPosLength(ulPosition, 
  366.   ulLength);
  367. }
  368. else
  369. {
  370.     AddToPendingList(pPlayerAdviseSink, ONPOSLENGTH, 
  371.      ulPosition, ulLength);
  372. }
  373.     }
  375.     return HXR_OK;
  376. }
  378. /************************************************************************
  379.  * Method:
  380.  *     IHXClientAdviseSink::OnPresentationOpened
  381.  * Purpose:
  382.  *     Called to advise the client a presentation has been opened.
  383.  */
  384. STDMETHODIMP CHXAdviseSinkControl::OnPresentationOpened()
  385. {
  386.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  387.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  388.     {
  389. PlayerAdviseSink* pPlayerAdviseSink = 
  390.     (PlayerAdviseSink*) (*lSinkerator);
  391. if (!m_pInterruptState->AtInterruptTime() || 
  392.     pPlayerAdviseSink->m_bInterruptSafe)
  393. {
  394.     ProcessPendingRequests(pPlayerAdviseSink);
  395.          pPlayerAdviseSink->m_pAdviseSink->OnPresentationOpened();
  396. }
  397. else
  398. {
  399.     AddToPendingList(pPlayerAdviseSink, ONPRESENTATIONOPENED);
  400. }
  401.     }
  403.     return HXR_OK;
  404. }
  407. /************************************************************************
  408.  * Method:
  409.  *     IHXClientAdviseSink::OnPresentationClosed
  410.  * Purpose:
  411.  *     Called to advise the client a presentation has been closed.
  412.  */
  413. STDMETHODIMP CHXAdviseSinkControl::OnPresentationClosed()
  414. {
  415.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  416.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  417.     {
  418. PlayerAdviseSink* pPlayerAdviseSink = 
  419.     (PlayerAdviseSink*) (*lSinkerator);
  420. if (!m_pInterruptState->AtInterruptTime() || 
  421.     pPlayerAdviseSink->m_bInterruptSafe)
  422. {
  423.     ProcessPendingRequests(pPlayerAdviseSink);
  424.          pPlayerAdviseSink->m_pAdviseSink->OnPresentationClosed();
  425. }
  426. else
  427. {
  428.     AddToPendingList(pPlayerAdviseSink, ONPRESENTATIONCLOSED);
  429. }
  430.     }
  432.     return HXR_OK;
  433. }
  435. /************************************************************************
  436.  * Method:
  437.  *     IHXClientAdviseSink::OnStatisticsChanged
  438.  * Purpose:
  439.  *     Called to advise the client that the presentation statistics
  440.  *     have changed. 
  441.  */
  442. STDMETHODIMP CHXAdviseSinkControl::OnStatisticsChanged(void)
  443. {
  444.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  445.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  446.     {
  447. PlayerAdviseSink* pPlayerAdviseSink = 
  448.     (PlayerAdviseSink*) (*lSinkerator);
  449. if (!m_pInterruptState->AtInterruptTime() || 
  450.     pPlayerAdviseSink->m_bInterruptSafe)
  451. {
  452.     ProcessPendingRequests(pPlayerAdviseSink);
  453.          pPlayerAdviseSink->m_pAdviseSink->OnStatisticsChanged();
  454. }
  455. else
  456. {
  457.     AddToPendingList(pPlayerAdviseSink, ONSTATISTICSCHANGED);
  458. }
  459.     }
  461.     return HXR_OK;
  462. }
  464. /************************************************************************
  465.  * Method:
  466.  *     IHXClientAdviseSink::OnPreSeek
  467.  * Purpose:
  468.  *     Called by client engine to inform the client that a seek is
  469.  *     about to occur. The render is informed the last time for the 
  470.  *     stream's time line before the seek, as well as the first new
  471.  *     time for the stream's time line after the seek will be completed.
  472.  *
  473.  */
  474. STDMETHODIMP CHXAdviseSinkControl::OnPreSeek( ULONG32 ulOldTime,
  475. ULONG32 ulNewTime)
  476. {
  477.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  478.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  479.     {
  480. PlayerAdviseSink* pPlayerAdviseSink = 
  481.     (PlayerAdviseSink*) (*lSinkerator);
  482. if (!m_pInterruptState->AtInterruptTime() || 
  483.     pPlayerAdviseSink->m_bInterruptSafe)
  484. {
  485.     ProcessPendingRequests(pPlayerAdviseSink);
  486.          pPlayerAdviseSink->m_pAdviseSink->OnPreSeek(ulOldTime, 
  487. ulNewTime);
  488. }
  489. else
  490. {
  491.     AddToPendingList(pPlayerAdviseSink, ONPRESEEK, 
  492.      ulOldTime, ulNewTime);
  493. }
  494.     }
  496.     return HXR_OK;
  497. }
  500. /************************************************************************
  501.  * Method:
  502.  *     IHXClientAdviseSink::OnPostSeek
  503.  * Purpose:
  504.  *     Called by client engine to inform the client that a seek has
  505.  *     just occured. The render is informed the last time for the 
  506.  *     stream's time line before the seek, as well as the first new
  507.  *     time for the stream's time line after the seek.
  508.  *
  509.  */
  510. STDMETHODIMP CHXAdviseSinkControl::OnPostSeek( ULONG32 ulOldTime,
  511. ULONG32 ulNewTime)
  512. {
  513.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  514.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  515.     {
  516. PlayerAdviseSink* pPlayerAdviseSink = 
  517.     (PlayerAdviseSink*) (*lSinkerator);
  518. if (!m_pInterruptState->AtInterruptTime() || 
  519.     pPlayerAdviseSink->m_bInterruptSafe)
  520. {
  521.     ProcessPendingRequests(pPlayerAdviseSink);
  522.          pPlayerAdviseSink->m_pAdviseSink->OnPostSeek(ulOldTime, 
  523.  ulNewTime);
  524. }
  525. else
  526. {
  527.     AddToPendingList(pPlayerAdviseSink, ONPOSTSEEK, 
  528.      ulOldTime, ulNewTime);
  529. }
  530.     }
  532.     return HXR_OK;
  533. }
  536. /************************************************************************
  537.  * Method:
  538.  *     IHXClientAdviseSink::OnStop
  539.  * Purpose:
  540.  *     Called by client engine to inform the client that a stop has
  541.  *     just occured. 
  542.  *
  543.  */
  544. STDMETHODIMP CHXAdviseSinkControl::OnStop(void)
  545. {
  546.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  547.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  548.     {
  549. PlayerAdviseSink* pPlayerAdviseSink = 
  550.     (PlayerAdviseSink*) (*lSinkerator);
  551. if (!m_pInterruptState->AtInterruptTime() || 
  552.     pPlayerAdviseSink->m_bInterruptSafe)
  553. {
  554.     ProcessPendingRequests(pPlayerAdviseSink);
  555.          pPlayerAdviseSink->m_pAdviseSink->OnStop();
  556. }
  557. else
  558. {
  559.     AddToPendingList(pPlayerAdviseSink, ONSTOP);
  560. }
  561.     }
  563.     return HXR_OK;
  564. }
  566. /************************************************************************
  567.  * Method:
  568.  *     IHXClientAdviseSink::OnPause
  569.  * Purpose:
  570.  *     Called by client engine to inform the client that a pause has
  571.  *     just occured. The render is informed the last time for the 
  572.  *     stream's time line before the pause.
  573.  *
  574.  */
  575. STDMETHODIMP CHXAdviseSinkControl::OnPause(ULONG32 ulTime)
  576. {
  577.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  578.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  579.     {
  580. PlayerAdviseSink* pPlayerAdviseSink = 
  581.     (PlayerAdviseSink*) (*lSinkerator);
  582. if (!m_pInterruptState->AtInterruptTime() || 
  583.     pPlayerAdviseSink->m_bInterruptSafe)
  584. {
  585.     ProcessPendingRequests(pPlayerAdviseSink);
  586.          pPlayerAdviseSink->m_pAdviseSink->OnPause(ulTime);
  587. }
  588. else
  589. {
  590.     AddToPendingList(pPlayerAdviseSink, ONPAUSE, ulTime);
  591. }
  592.     }
  594.     return HXR_OK;
  595. }
  598. /************************************************************************
  599.  * Method:
  600.  *     IHXClientAdviseSink::OnBegin
  601.  * Purpose:
  602.  *     Called by client engine to inform the client that a begin or
  603.  *     resume has just occured. The render is informed the first time 
  604.  *     for the stream's time line after the resume.
  605.  *
  606.  */
  607. STDMETHODIMP CHXAdviseSinkControl::OnBegin(ULONG32 ulTime)
  608. {
  609.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  610.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  611.     {
  612. PlayerAdviseSink* pPlayerAdviseSink = 
  613.     (PlayerAdviseSink*) (*lSinkerator);
  614. if (!m_pInterruptState->AtInterruptTime() || 
  615.     pPlayerAdviseSink->m_bInterruptSafe)
  616. {
  617.     ProcessPendingRequests(pPlayerAdviseSink);
  618.          pPlayerAdviseSink->m_pAdviseSink->OnBegin(ulTime);
  619. }
  620. else
  621. {
  622.     AddToPendingList(pPlayerAdviseSink, ONBEGIN, ulTime);
  623. }
  624.     }
  626.     return HXR_OK;
  627. }
  630. /************************************************************************
  631.  * Method:
  632.  *     IHXClientAdviseSink::OnBuffering
  633.  * Purpose:
  634.  *     Called by client engine to inform the client that buffering
  635.  *     of data is occuring. The render is informed of the reason for
  636.  *     the buffering (start-up of stream, seek has occured, network
  637.  *     congestion, etc.), as well as percentage complete of the 
  638.  *     buffering process.
  639.  *
  640.  */
  641. STDMETHODIMP CHXAdviseSinkControl::OnBuffering(ULONG32 ulFlags,
  642. UINT16 unPercentComplete)
  643. {
  644.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  645.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  646.     {
  647. PlayerAdviseSink* pPlayerAdviseSink = 
  648.     (PlayerAdviseSink*) (*lSinkerator);
  649. if (!m_pInterruptState->AtInterruptTime() || 
  650.     pPlayerAdviseSink->m_bInterruptSafe)
  651. {
  652.     ProcessPendingRequests(pPlayerAdviseSink);
  653.          pPlayerAdviseSink->m_pAdviseSink->OnBuffering(ulFlags, 
  654.   unPercentComplete);
  655. }
  656. else
  657. {
  658.     AddToPendingList(pPlayerAdviseSink, ONBUFFERING, 
  659.      ulFlags, (UINT32) unPercentComplete);
  660. }
  661.     }
  663.     return HXR_OK;
  664. }
  667. /************************************************************************
  668.  * Method:
  669.  *     IHXClientAdviseSink::OnContacting
  670.  * Purpose:
  671.  *     Called by client engine to inform the client is contacting
  672.  *     hosts(s).
  673.  *
  674.  */
  675. STDMETHODIMP CHXAdviseSinkControl::OnContacting(const char* pHostName)
  676. {
  677.     CHXSimpleList::Iterator lSinkerator = m_pSinkList.Begin();
  678.     for (;  lSinkerator != m_pSinkList.End(); ++lSinkerator)
  679.     {
  680. PlayerAdviseSink* pPlayerAdviseSink = 
  681.     (PlayerAdviseSink*) (*lSinkerator);
  682. if (!m_pInterruptState->AtInterruptTime() || 
  683.     pPlayerAdviseSink->m_bInterruptSafe)
  684. {
  685.     ProcessPendingRequests(pPlayerAdviseSink);
  686.          pPlayerAdviseSink->m_pAdviseSink->OnContacting(pHostName);
  687. }
  688. else
  689. {
  690.     AddToPendingList(pPlayerAdviseSink, ONCONTACTING, 
  691.      0, 0, (char*) pHostName);
  692. }
  693.     }
  695.     return HXR_OK;
  696. }
  699. void CHXAdviseSinkControl::AdviseSinkCallback(void* pParam)
  700. {
  701.     CHXAdviseSinkControl* pObj = (CHXAdviseSinkControl*)pParam;
  702.     
  703.     if (pObj)
  704.     {
  705.         pObj->ProcessAllRequests();
  706.     }
  707. }    
  710. /************************************************************************
  712. /* CHXErrorSinkControl */
  714. CHXErrorSinkControl::CHXErrorSinkControl() :
  715.      m_lRefCount (0)
  716.     ,m_pPendingErrorList(NULL) 
  717.     ,m_pInterruptState(NULL)
  718.     ,m_pScheduler(NULL)
  719.     ,m_pErrorCallback(NULL)
  720. {
  721.     m_pErrorCallback = new CHXGenericCallback((void*)this, (fGenericCBFunc)ErrorCallback);
  722.     m_pErrorCallback->AddRef();
  723. }
  725. CHXErrorSinkControl::~CHXErrorSinkControl()
  726. {
  727.     Close();
  728. }
  730. STDMETHODIMP
  731. CHXErrorSinkControl::AddErrorSink (
  732. IHXErrorSink* pErrorSink,
  733.                                 const UINT8     unLowSeverity,
  734.                                 const UINT8     unHighSeverity)
  735. {
  736.     if (pErrorSink)
  737.     {
  738.      PlayerErrorSink* pPlayerErrorSink = new PlayerErrorSink(pErrorSink, unLowSeverity, unHighSeverity);
  739.      m_pSinkList.AddTail(pPlayerErrorSink);
  740.      pErrorSink->AddRef();
  741.     
  742.     }
  743.     return HXR_OK;
  744. }
  746. STDMETHODIMP
  747. CHXErrorSinkControl::RemoveErrorSink(IHXErrorSink* pErrorSink)
  748. {
  749.     PlayerErrorSink* pPlayerErrorSink;
  750.     CHXSimpleList::Iterator lIterator = m_pSinkList.Begin();
  751.     for (; lIterator != m_pSinkList.End(); ++lIterator)
  752.     {
  753. pPlayerErrorSink = (PlayerErrorSink *) (*lIterator);
  754.      if (pPlayerErrorSink->m_pErrorSink == pErrorSink)
  755.      {
  756.     HX_RELEASE (pErrorSink);
  757.     
  758.     LISTPOSITION pos = m_pSinkList.Find(pPlayerErrorSink);
  759.     m_pSinkList.RemoveAt(pos);     
  760.     delete pPlayerErrorSink;
  761.     return HXR_OK;
  762.      }
  763.     }
  764.     return HXR_FAIL;
  765. }
  767. STDMETHODIMP 
  768. CHXErrorSinkControl::QueryInterface(REFIID riid, void** ppvObj)
  769. {
  770.     QInterfaceList qiList[] =
  771.         {
  772.             { GET_IIDHANDLE(IID_IHXErrorSinkControl), (IHXErrorSinkControl*)this },
  773.             { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXErrorSinkControl*)this },
  774.         };
  775.     
  776.     return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
  777. }
  779. STDMETHODIMP_ (ULONG32) 
  780. CHXErrorSinkControl::AddRef()
  781. {
  782.     return InterlockedIncrement(&m_lRefCount);
  783. }
  785. STDMETHODIMP_ (ULONG32) 
  786. CHXErrorSinkControl::Release()
  787. {
  788.     if (InterlockedDecrement(&m_lRefCount) > 0)
  789.     {
  790. return m_lRefCount;
  791.     }
  793.     delete this;
  794.     return 0;
  795. }
  797. void 
  798. CHXErrorSinkControl::GetSeverityRange(IHXErrorSink* pErrorSink, 
  799. UINT8& unLowSeverity, 
  800.      UINT8& unHighSeverity)
  801. {
  802.     PlayerErrorSink* pPlayerErrorSink;
  803.     CHXSimpleList::Iterator lIterator = m_pSinkList.Begin();
  804.     for (; lIterator != m_pSinkList.End(); ++lIterator)
  805.     {
  806. pPlayerErrorSink = (PlayerErrorSink *) (*lIterator);
  807.      if (pPlayerErrorSink->m_pErrorSink == pErrorSink)
  808.      {
  809.     unLowSeverity = pPlayerErrorSink->m_unLowSeverity;
  810.     unHighSeverity = pPlayerErrorSink->m_unHighSeverity;
  811.     break;
  812.      }
  813.     }
  814. }
  816. void
  817. CHXErrorSinkControl::Init(IHXClientEngine* pEngine)
  818. {
  819.     pEngine->QueryInterface(IID_IHXInterruptState, 
  820. (void**) &m_pInterruptState);
  821.     
  822.     pEngine->QueryInterface(IID_IHXScheduler, (void**) &m_pScheduler);
  823. }
  825. void 
  826. CHXErrorSinkControl::Close()
  827. {
  828.     PlayerErrorSink* pPlayerErrorSink;
  829.     CHXSimpleList::Iterator lIterator = m_pSinkList.Begin();
  830.     for (; lIterator != m_pSinkList.End(); ++lIterator)
  831.     {
  832. pPlayerErrorSink = (PlayerErrorSink *) (*lIterator);
  833. HX_RELEASE (pPlayerErrorSink->m_pErrorSink);
  834. delete pPlayerErrorSink;
  835.     }
  837.     m_pSinkList.RemoveAll();
  839.     while (m_pPendingErrorList && m_pPendingErrorList->GetCount() > 0)
  840.     {
  841. ErrorReport* pErrorReport = 
  842.     (ErrorReport*) m_pPendingErrorList->RemoveHead();
  843. delete pErrorReport;
  844.     }
  846.     
  847.     if (m_pErrorCallback)
  848.     {
  849.         m_pScheduler->Remove(m_pErrorCallback->GetPendingCallback());
  850.         m_pErrorCallback->CallbackCanceled();
  851.         HX_RELEASE(m_pErrorCallback);
  852.     }
  854.     HX_DELETE(m_pPendingErrorList);
  855.     HX_RELEASE(m_pInterruptState);
  856.     HX_RELEASE(m_pScheduler);
  857. }
  859. HX_RESULT 
  860. CHXErrorSinkControl::ErrorOccurred( const UINT8 unSeverity,  
  861.     const ULONG32 ulHXCode,
  862.     const ULONG32 ulUserCode,
  863.     const char* pUserString,
  864.     const char* pMoreInfoURL)
  865. {
  866.     if (m_pInterruptState->AtInterruptTime())
  867.     {
  868. if (!m_pPendingErrorList)
  869. {
  870.     m_pPendingErrorList = new CHXSimpleList;
  871. }
  873. ErrorReport* pErrorReport = new ErrorReport;
  874. pErrorReport->m_unSeverity = unSeverity;
  875. pErrorReport->m_ulHXCode = ulHXCode;
  876. pErrorReport->m_ulUserCode = ulUserCode;
  878. if (pUserString && *pUserString)
  879. {
  880.     pErrorReport->m_pUserString = new char[strlen(pUserString) + 1];
  881.     ::strcpy(pErrorReport->m_pUserString, pUserString); /* Flawfinder: ignore */
  882. }
  884. if (pMoreInfoURL && *pMoreInfoURL)
  885. {
  886.     pErrorReport->m_pMoreInfoURL = new char[strlen(pMoreInfoURL) + 1];
  887.     ::strcpy(pErrorReport->m_pMoreInfoURL, pMoreInfoURL); /* Flawfinder: ignore */
  888. }
  890. m_pPendingErrorList->AddTail((void*) pErrorReport);
  892.         if (!m_pErrorCallback->GetPendingCallback())
  893. {
  894.             m_pErrorCallback->CallbackScheduled(
  895.              m_pScheduler->RelativeEnter(m_pErrorCallback, 0));
  896. }
  898. return HXR_OK;
  899.     }
  901.     ReportPendingErrors();
  903.     CallReport(unSeverity,
  904.        ulHXCode,
  905.        ulUserCode,
  906.        pUserString,
  907.        pMoreInfoURL);
  909.     return HXR_OK;
  910. }
  912. void
  913. CHXErrorSinkControl::ReportPendingErrors()
  914. {
  915.     if (m_pErrorCallback)
  916.     {
  917.         m_pScheduler->Remove(m_pErrorCallback->GetPendingCallback());
  918.         m_pErrorCallback->CallbackCanceled();
  919.     }
  921.     while (m_pPendingErrorList && m_pPendingErrorList->GetCount() > 0)
  922.     {
  923. ErrorReport* pErrorReport = 
  924.     (ErrorReport*) m_pPendingErrorList->RemoveHead();
  925. CallReport(pErrorReport->m_unSeverity,
  926.    pErrorReport->m_ulHXCode,
  927.    pErrorReport->m_ulUserCode,
  928.    pErrorReport->m_pUserString,
  929.    pErrorReport->m_pMoreInfoURL);
  930. delete pErrorReport;
  931.     }
  932. }
  934. HX_RESULT
  935. CHXErrorSinkControl::CallReport
  936. (
  937.     const UINT8 unSeverity,  
  938.     HX_RESULT ulHXCode,
  939.     const ULONG32 ulUserCode,
  940.     const char* pUserString,
  941.     const char* pMoreInfoURL
  942. )
  943. {
  944.     CHXSimpleList::Iterator ndxSink;
  945.     for (ndxSink = m_pSinkList.Begin(); 
  946.  ndxSink != m_pSinkList.End(); ++ndxSink)
  947.     {
  948. PlayerErrorSink* pPlayerErrorSink =
  949. (PlayerErrorSink*) (*ndxSink);
  951. // error-reporting based on its severity   
  952. if (unSeverity >= pPlayerErrorSink->m_unLowSeverity &&
  953.     unSeverity <= pPlayerErrorSink->m_unHighSeverity)
  954. //     unSeverity <= pPlayerErrorSink->m_unHighSeverity && !m_pAltURLs->GetCount())
  955. {
  956.     pPlayerErrorSink->m_pErrorSink->ErrorOccurred(unSeverity, ulHXCode,
  957. ulUserCode, pUserString, pMoreInfoURL);
  958. }
  959.     }
  961.     return HXR_OK;
  962. }
  965. void CHXErrorSinkControl::ErrorCallback(void* pParam)
  966. {
  967.     CHXErrorSinkControl* pObj = (CHXErrorSinkControl*)pParam;
  969.     if (pObj)
  970.     {
  971.         pObj->ReportPendingErrors();
  972.     }
  973. }