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

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

Symbian

开发平台：

C/C++

hxplay.h：源码内容
  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. #ifndef _HXPLAYER_
  37. #define _HXPLAYER_
  39. #include "hxtypes.h"
  40. #include "hxcomm.h" // IHXRegistryID
  41. #include "hxfiles.h"
  42. #include "hxsmbw.h"
  43. #include "hxresult.h"
  44. #include "hxslist.h"
  45. #include "chxelst.h"
  46. #include "hxmap.h"
  47. #include "chxpckts.h"
  48. #include "hxurl.h"
  49. #include "hxtick.h"
  50. #include "hxmon.h"
  51. #include "hxclreg.h"
  52. #include "statinfo.h"
  53. #include "strminfo.h"
  54. #include "hxauth.h"
  55. #include "hxpreftr.h"
  56. #include "hxvsrc.h"
  58. //#include "prefkeys.h"
  59. #include "plprefk.h"
  60. //#include "domain.h"  // Needed for domain object
  62. #include "timeval.h"
  63. #include "hxausvc.h"
  64. #include "hxpends.h"
  65. #include "hxerror.h"
  66. #include "hxmeta.h"
  67. #include "chxphook.h"
  68. #include "hxwin.h"
  69. #include "hxcorgui.h"
  70. #include "smartptr.h"
  71. #include "miscsp.h"
  72. #include "hxrquest.h"
  73. #include "perscmgr.h"
  74. #include "hxbsrc.h"
  75. #include "hxsrc.h"
  76. #include "hxcbobj.h"
  78. #ifdef _SYMBIAN
  79. //XXXgfw Wow, symbian's unistd.h #defines remove to be unlink.
  80. //Very uncool.
  81. #undef remove
  82. #endif
  84. // forward decl.
  85. _INTERFACE IHXPlayer;
  86. _INTERFACE IHXPlayer2;
  87. _INTERFACE IHXAudioPlayerResponse;
  88. _INTERFACE IHXClientEngine;
  89. _INTERFACE IHXRenderer;
  90. _INTERFACE IHXScheduler;
  91. _INTERFACE IHXClientAdviseSink;
  92. _INTERFACE IHXMetaTrack;
  93. _INTERFACE IHXMetaLayout;
  94. _INTERFACE IHXErrorMessages;
  95. _INTERFACE IHXPreferences;
  96. _INTERFACE IHXHyperNavigate;
  97. _INTERFACE IHXAuthenticationManager;
  98. _INTERFACE IHXSiteSupplier;
  99. _INTERFACE IHXSiteLayout;
  100. _INTERFACE IHXUpgradeCollection;
  101. _INTERFACE IHXGroupSink;
  102. _INTERFACE IHXGroup;
  103. _INTERFACE IHXPlayerState;
  104. _INTERFACE IHXProxyManager;
  105. _INTERFACE IHXViewSourceCommand;
  106. _INTERFACE IHXViewPortManager;
  107. #if defined(HELIX_FEATURE_MEDIAMARKER)
  108. _INTERFACE IHXMediaMarkerManager;
  109. #endif /* #if defined(HELIX_FEATURE_MEDIAMARKER) */
  110. #if defined(HELIX_FEATURE_EVENTMANAGER)
  111. _INTERFACE IHXEventManager;
  112. #endif /* #if defined(HELIX_FEATURE_EVENTMANAGER) */
  113. _INTERFACE IHXPlayerNavigator;
  114. _INTERFACE IHXClientRequestSink;
  116. class CHXSiteManager;
  118. class CHXAudioPlayer;
  119. class HXClientEngine;
  120. class HXSource;
  121. class HXFileSource;
  122. class HXNetSource;
  123. class HXStream;
  125. class HXPlayerCallback;
  126. class UpdateStatsCallback;
  127. class CHXAdviseSinkControl;
  128. class CHXErrorSinkControl;
  129. class HXCookies;
  131. class Timeline;
  132. class Timeval;
  133. class HXMutex;
  135. class Plugin2Handler;
  136. struct IHXPlugin2Handler;
  139. class HXPersistentComponentManager;
  140. class HXPreferredTransportManager;
  142. #ifdef _UNIX
  143. _INTERFACE IHXSiteEventHandler;
  144. #endif
  146. struct STREAM_INFO;
  148. typedef ULONG32 BufferingReason;
  150. struct RendererInfo;
  151. class  SourceInfo;
  152. class HXPlayer;
  153. class UpdateStatsCallback;
  154. class HXPlayerCallback;
  155. class HXBasicGroupManager;
  156. class HXAdvancedGroupManager;
  157. class NextGroupManager;
  158. class PrefetchManager;
  159. class HXMasterTAC;
  160. class PlayerHyperNavigate;
  162. struct IHXBandwidthManager;
  164. class CHXEvent;
  165. class CHXSimpleList;
  166. class CHXMapStringToOb;
  167. class HXViewPortManager;
  168. #if defined(HELIX_FEATURE_MEDIAMARKER)
  169. class CHXMediaMarkerManager;
  170. #endif /* #if defined(HELIX_FEATURE_MEDIAMARKER) */
  171. #if defined(HELIX_FEATURE_EVENTMANAGER)
  172. class CRendererEventManager;
  173. #endif /* #if defined(HELIX_FEATURE_EVENTMANAGER) */
  175. #define DEFAULT_TIMESYNC_GRANULARITY 100
  176. /* Lowest allowable time sync granularity */
  177. #define MINIMUM_TIMESYNC_GRANULARITY 20
  179. #ifndef _WIN16
  180. //#if defined(HELIX_FEATURE_AUTHENTICATION)
  181. typedef WRAPPED_POINTER(IUnknown) Wrapped_IUnknown;
  183. class _CListOfWrapped_IUnknown_Node
  184. {
  185. #ifdef HELIX_FEATURE_AUTHENTICATION
  186. public:
  187.     _CListOfWrapped_IUnknown_Node();
  188.     ~_CListOfWrapped_IUnknown_Node();
  190.     Wrapped_IUnknown& value();
  191.     const Wrapped_IUnknown& value() const;
  192.     void value(const Wrapped_IUnknown& rclsNewValue);
  193.     _CListOfWrapped_IUnknown_Node& operator=(const Wrapped_IUnknown& rclsNewValue); 
  194.     _CListOfWrapped_IUnknown_Node* next() const;
  195.     void next(_CListOfWrapped_IUnknown_Node* plocnNew);
  196.     _CListOfWrapped_IUnknown_Node* prev() const;
  197.     void prev(_CListOfWrapped_IUnknown_Node* plocnNew);
  198.     void Remove();
  199.     void Insert(_CListOfWrapped_IUnknown_Node& rlocnNew);
  201. protected:
  202.     Wrapped_IUnknown m_clsValue;
  203.     _CListOfWrapped_IUnknown_Node* m_plocPrev;
  204.     _CListOfWrapped_IUnknown_Node* m_plocNext;
  205.     _CListOfWrapped_IUnknown_Node(const _CListOfWrapped_IUnknown_Node& rlocnOther){}
  206. #endif /* HELIX_FEATURE_AUTHENTICATION */
  207. };
  209. class _CListIteratorWrapped_IUnknown_;
  210. class _CListReverseIteratorWrapped_IUnknown_;
  212. class _CListOfWrapped_IUnknown_
  213. {
  214. public:
  215.     typedef _CListIteratorWrapped_IUnknown_ iterator;
  216.     typedef _CListReverseIteratorWrapped_IUnknown_ reverse_iterator;
  217.     typedef const _CListReverseIteratorWrapped_IUnknown_ const_reverse_iterator;
  219. #ifdef HELIX_FEATURE_AUTHENTICATION
  220.     _CListOfWrapped_IUnknown_();
  221.     _CListOfWrapped_IUnknown_(const _CListOfWrapped_IUnknown_& rlocOther);
  222.     ~_CListOfWrapped_IUnknown_();
  223.     _CListOfWrapped_IUnknown_& operator=(const _CListOfWrapped_IUnknown_& rlocOther); 
  225.     iterator begin();
  226.     const iterator begin() const;
  227.     iterator end();
  228.     const iterator end() const;
  230.     reverse_iterator rbegin();
  231.     const reverse_iterator rbegin() const;
  232.     reverse_iterator rend();
  233.     const reverse_iterator rend() const;
  235.     iterator insert(iterator itBefore, const Wrapped_IUnknown&);
  236.     void insert
  237.     (
  238. iterator itBefore,
  239. const iterator itFirst,
  240. const iterator itLast
  241.     );
  242.     void remove(iterator itThis);
  243.     void remove(iterator itFirst, iterator itLast);
  245.     void empty();
  247. protected:
  248.     _CListOfWrapped_IUnknown_Node m_locnREnd;
  249.     _CListOfWrapped_IUnknown_Node m_locnEnd;
  251.     void _copy(const _CListOfWrapped_IUnknown_& rlocOther);
  252. #endif /* HELIX_FEATURE_AUTHENTICATION */
  253. };
  255. class _CListIteratorWrapped_IUnknown_
  256. {
  257. #ifdef HELIX_FEATURE_AUTHENTICATION
  258. public:
  259.     _CListIteratorWrapped_IUnknown_();
  260.     _CListIteratorWrapped_IUnknown_
  261.     (
  262.         const _CListOfWrapped_IUnknown_Node& rlocnNewLocation
  263.     );
  264.     _CListIteratorWrapped_IUnknown_(const _CListIteratorWrapped_IUnknown_& rliocOther);
  265.     ~_CListIteratorWrapped_IUnknown_();
  267.     _CListIteratorWrapped_IUnknown_& operator=
  268.     (
  269. const _CListIteratorWrapped_IUnknown_& rliocOther
  270.     );
  272.     Wrapped_IUnknown& operator*();
  273.     _CListIteratorWrapped_IUnknown_& operator=(const Wrapped_IUnknown& rclsNewValue);
  275.     _CListIteratorWrapped_IUnknown_& operator++();
  276.     const _CListIteratorWrapped_IUnknown_ operator++(int);
  278.     _CListIteratorWrapped_IUnknown_& operator--();
  279.     const _CListIteratorWrapped_IUnknown_ operator--(int);
  281. private:
  282.     _CListOfWrapped_IUnknown_Node* m_plocCurrent;
  284.     friend class _CListOfWrapped_IUnknown_;
  285.     friend BOOL operator==
  286.     (
  287. const _CListIteratorWrapped_IUnknown_& rliocLeft,
  288. const _CListIteratorWrapped_IUnknown_& rliocRight
  289.     );
  290.     friend BOOL operator!=
  291.     (
  292. const _CListIteratorWrapped_IUnknown_& rliocLeft,
  293. const _CListIteratorWrapped_IUnknown_& rliocRight
  294.     );
  295. #endif /* HELIX_FEATURE_AUTHENTICATION */
  296. };
  298. #ifdef HELIX_FEATURE_AUTHENTICATION
  299. BOOL operator==
  300. (
  301.     const _CListIteratorWrapped_IUnknown_& rliocLeft,
  302.     const _CListIteratorWrapped_IUnknown_& rliocRight
  303. );
  305. BOOL operator!=
  306. (
  307.     const _CListIteratorWrapped_IUnknown_& rliocLeft,
  308.     const _CListIteratorWrapped_IUnknown_& rliocRight
  309. );
  310. #endif /* HELIX_FEATURE_AUTHENTICATION */
  312. class _CListReverseIteratorWrapped_IUnknown_
  313. {
  314. #ifdef HELIX_FEATURE_AUTHENTICATION
  315. public:
  316.     _CListReverseIteratorWrapped_IUnknown_();
  317.     _CListReverseIteratorWrapped_IUnknown_
  318.     (
  319.         const _CListOfWrapped_IUnknown_Node& rlocnNewLocation
  320.     );
  321.     _CListReverseIteratorWrapped_IUnknown_
  322.     (
  323. const _CListReverseIteratorWrapped_IUnknown_& rlriocOther
  324.     );
  325.     ~_CListReverseIteratorWrapped_IUnknown_();
  327.     _CListReverseIteratorWrapped_IUnknown_& operator=
  328.     (
  329. const _CListReverseIteratorWrapped_IUnknown_& rlriocOther
  330.     );
  332.     Wrapped_IUnknown& operator*();
  333.     _CListReverseIteratorWrapped_IUnknown_& operator=(const Wrapped_IUnknown& rclsNewValue);
  335.     _CListReverseIteratorWrapped_IUnknown_& operator++();
  336.     const _CListReverseIteratorWrapped_IUnknown_ operator++(int);
  337.     _CListReverseIteratorWrapped_IUnknown_& operator--();
  338.     const _CListReverseIteratorWrapped_IUnknown_ operator--(int);
  340. private:
  341.     _CListOfWrapped_IUnknown_Node* m_plocCurrent;
  342.     friend class _CListOfWrapped_IUnknown_;
  343.     friend BOOL operator==
  344.     (
  345. const _CListReverseIteratorWrapped_IUnknown_& rlriocLeft,
  346. const _CListReverseIteratorWrapped_IUnknown_& rlriocRight
  347.     );
  348.     friend BOOL operator!=
  349.     (
  350. const _CListReverseIteratorWrapped_IUnknown_& rlriocLeft,
  351. const _CListReverseIteratorWrapped_IUnknown_& rlriocRight
  352.     );
  353. #endif /* HELIX_FEATURE_AUTHENTICATION */
  354. };
  356. #ifdef HELIX_FEATURE_AUTHENTICATION
  357. BOOL operator==
  358. (
  359.     const _CListReverseIteratorWrapped_IUnknown_& rlriocLeft,
  360.     const _CListReverseIteratorWrapped_IUnknown_& rlriocRight
  361. );
  362. BOOL operator!=
  363. (
  364.     const _CListReverseIteratorWrapped_IUnknown_& rlriocLeft,
  365.     const _CListReverseIteratorWrapped_IUnknown_& rlriocRight
  366. );     
  367. #endif /* HELIX_FEATURE_AUTHENTICATION */
  369. class _CHXAuthenticationRequests
  370. {
  371. public:
  372.     _CHXAuthenticationRequests();
  373.     ~_CHXAuthenticationRequests();
  375.     HX_RESULT Add
  376.     (
  377. HXPlayer* pPlayerRequester, 
  378. IHXAuthenticationManagerResponse* pAuthenticationManagerResponseRequester,
  379. IHXValues* pAuthenticationHeaderValues
  380.     );
  381.     HX_RESULT SatisfyPending
  382.     (
  383. HX_RESULT ResultStatus, 
  384. const char* pCharUser, 
  385. const char* pCharPassword
  386.     );
  387.     void     ClearPendingList();
  388. private:
  389.     _CListOfWrapped_IUnknown_ m_ListOfIUnknownRequesters;
  390.     HXMutex* m_pMutexProtectList;
  391.     BOOL m_bUIShowing;
  392. };
  393. //#endif /* HELIX_FEATURE_AUTHENTICATION */
  395. struct RedirectInfo
  396. {
  397.     RedirectInfo()
  398.     {
  399. m_nGroupID = 0;
  400. m_nTrackID = 0;
  401. m_pURL = NULL;
  402.     }
  404.     ~RedirectInfo()
  405.     {
  406. HX_VECTOR_DELETE(m_pURL);
  407.     }
  409.     UINT16  m_nGroupID;
  410.     UINT16  m_nTrackID;
  411.     char*   m_pURL;
  412. };
  414. struct PendingTrackInfo
  415. {
  416.     PendingTrackInfo(UINT16     uGroupIndex, 
  417.      UINT16     uTrackIndex,
  418.      IHXValues*    pTrack)
  419.     {
  420. m_uGroupIndex = uGroupIndex;
  421. m_uTrackIndex = uTrackIndex;
  422. m_pTrack = pTrack;
  423. m_pTrack->AddRef();
  424.     }
  426.     ~PendingTrackInfo()
  427.     {
  428. HX_RELEASE(m_pTrack);
  429.     }
  431.     UINT16    m_uGroupIndex;
  432.     UINT16    m_uTrackIndex;
  433.     IHXValues*   m_pTrack;
  434. };
  435. #endif /* _WIN16 */
  437. class HXPlayer :   public IHXPlayer, 
  438.     public IHXPlayer2,
  439.     public IHXAudioPlayerResponse,
  440.     public IHXPendingStatus,
  441.     public IHXErrorMessages,
  442.     public IHXAuthenticationManager,
  443.     public IHXAuthenticationManager2,
  444.     public IHXAuthenticationManagerResponse,
  445.     public IHXRegistryID,
  446.     public IHXGroupSink,
  447.     public IHXLayoutSiteGroupManager,
  448.     public IHXRendererUpgrade,
  449.     public IHXInternalReset,
  450.     public IHXPlayerState,
  451.     public IHXViewSourceCommand,
  452.     public IHXOverrideDefaultServices,
  453.     public IHXPlayerNavigator,
  454.     public IHXClientStatisticsGranularity,
  455.     public IHXPlayerPresentation,
  456.                     public IHXRecordManager
  457. {
  458. protected:
  459.     LONG32 m_lRefCount;
  460.     UINT32 m_ulRepeatedRegistryID;
  461.     UINT32 m_ulNextGroupRegistryID;
  462.     HX_RESULT m_LastError;
  463.     char* m_pLastUserString;
  464.     UINT8 m_LastSeverity;
  465.     UINT32 m_ulLastUserCode;
  466.     char* m_pLastMoreInfoURL;
  468. #if defined(HELIX_FEATURE_REGISTRY)    
  469.     // statistic variables
  470.     HXClientRegistry* m_pRegistry;
  471. #else
  472.     void* m_pRegistry;
  473. #endif /* HELIX_FEATURE_REGISTRY */
  475. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  476.     PLAYER_STATS* m_pStats;
  477.     UpdateStatsCallback* m_pUpdateStatsCallback;
  478. #else
  479.     void* m_pStats;
  480.     void* m_pUpdateStatsCallback;
  481. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  483.     CHXGenericCallback* m_pHXPlayerCallback;
  484.     CHXGenericCallback* m_pHXPlayerInterruptCallback;
  485.     CHXGenericCallback* m_pSetupCallback;
  486. #if defined(HELIX_FEATURE_AUTHENTICATION)
  487.     CHXGenericCallback* m_pAuthenticationCallback;
  488. #else
  489.     void* m_pAuthenticationCallback;
  490. #endif /* HELIX_FEATURE_AUTHENTICATION */
  491.     IHXValues* m_pAutheticationValues;
  493.     ULONG32 m_ulStatsGranularity;
  495. public:
  496.     HXClientEngine* m_pEngine;
  497.     IHXPlugin2Handler* m_pPlugin2Handler;
  498. protected:
  499.     IUnknown* m_pClient;
  500.     CHXAudioPlayer* m_pAudioPlayer;
  501.     
  502.     CHXAdviseSinkControl* m_pAdviseSink;
  503.     CHXErrorSinkControl*   m_pErrorSinkControl;
  504.     
  505.     IHXClientRequestSink* m_pClientRequestSink;
  506.     IHXPreferences* m_pPreferences;
  507. #if defined(HELIX_FEATURE_HYPER_NAVIGATE)
  508.     PlayerHyperNavigate* m_pHyperNavigate;
  509. #else
  510.     void* m_pHyperNavigate;
  511. #endif /* HELIX_FEATURE_HYPER_NAVIGATE */
  512. #if defined(HELIX_FEATURE_PACKETHOOKMGR)
  513.     IHXPacketHookManager* m_pPacketHookManager;
  514. #else
  515.     void* m_pPacketHookManager;
  516. #endif /* HELIX_FEATURE_PACKETHOOKMGR */
  518. #if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
  519.     HXAdvancedGroupManager*     m_pGroupManager;
  520. #else
  521.     HXBasicGroupManager* m_pGroupManager;
  522. #endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */
  524.     HXMasterTAC* m_pMasterTAC;
  526.     CHXSimpleList* m_pRedirectList;
  528.     IHXClientViewSource* m_pClientViewSource;
  529.     IHXClientViewRights* m_pClientViewRights;
  530.     IHXViewPortManager* m_pViewPortManager;
  531. #if defined(HELIX_FEATURE_MEDIAMARKER)
  532.     CHXMediaMarkerManager*     m_pMediaMarkerManager;
  533. #else
  534.     void* m_pMediaMarkerManager;
  535. #endif /* #if defined(HELIX_FEATURE_MEDIAMARKER) */
  536. #if defined(HELIX_FEATURE_EVENTMANAGER)
  537.     CRendererEventManager*      m_pEventManager;
  538. #else
  539.     void* m_pEventManager;
  540. #endif /* #if defined(HELIX_FEATURE_EVENTMANAGER) */
  541.     HXCookies* m_pCookies;
  543. #if defined(HELIX_FEATURE_NESTEDMETA)
  544.     HXPersistentComponentManager*  m_pPersistentComponentManager;
  545. #else
  546.     void* m_pPersistentComponentManager;
  547. #endif /* HELIX_FEATURE_NESTEDMETA */
  548.     HXPreferredTransportManager*   m_pPreferredTransportManager;
  549.     IHXNetInterfaces*     m_pNetInterfaces;
  551. public:
  552. HXPlayer();
  553. ~HXPlayer();
  555.     /*
  556.      * IUnknown methods
  557.      */
  558.     STDMETHOD(QueryInterface) (THIS_
  559. REFIID riid,
  560. void** ppvObj);
  562.     STDMETHOD_(ULONG32,AddRef) (THIS);
  564.     STDMETHOD_(ULONG32,Release) (THIS);
  566.     /*
  567.      * IHXPlayer methods
  568.      */
  570.     /************************************************************************
  571.      * Method:
  572.      * IHXPlayer::GetClientEngine
  573.      * Purpose:
  574.      * Get the interface to the client engine object of which the player
  575.      * is a part of.
  576.      *
  577.      */
  578.     STDMETHOD(GetClientEngine) (THIS_
  579.     REF(IHXClientEngine*) pEngine);
  581.     /************************************************************************
  582.      * Method:
  583.      * IHXPlayer::OpenURL
  584.      * Purpose:
  585.      * Tell the player to begin playback of all its sources.
  586.      *
  587.      */
  588.     STDMETHOD (OpenURL) (THIS_
  589.     const char* pURL);
  591.     /************************************************************************
  592.      * Method:
  593.      * IHXPlayer::Begin
  594.      * Purpose:
  595.      * Tell the player to begin playback of all its sources.
  596.      *
  597.      */
  598.     STDMETHOD (Begin) (THIS);
  600.     /************************************************************************
  601.      * Method:
  602.      * IHXPlayer::Stop
  603.      * Purpose:
  604.      * Tell the player to stop playback of all its sources.
  605.      *
  606.      */
  607.     STDMETHOD (Stop) (THIS);
  609.     /************************************************************************
  610.      * Method:
  611.      * IHXPlayer::Pause
  612.      * Purpose:
  613.      * Tell the player to pause playback of all its sources.
  614.      *
  615.      */
  616.     STDMETHOD (Pause) (THIS);
  618.     /************************************************************************
  619.      * Method:
  620.      * IHXPlayer::Seek
  621.      * Purpose:
  622.      * Tell the player to seek in the playback timeline of all its 
  623.      * sources.
  624.      *
  625.      */
  626.     STDMETHOD (Seek) (THIS_
  627. ULONG32 ulTime);
  629.     /************************************************************************
  630.      * Method:
  631.      *     IHXPlayer::GetSourceCount
  632.      * Purpose:
  633.      *     Returns the current number of source instances supported by
  634.      *     this player instance.
  635.      */
  636.     STDMETHOD_(UINT16, GetSourceCount)(THIS);
  638.     /************************************************************************
  639.      * Method:
  640.      *     IHXPlayer::GetSource
  641.      * Purpose:
  642.      *     Returns the Nth source instance supported by this player.
  643.      */
  644.     STDMETHOD(GetSource) (THIS_
  645. UINT16 nIndex,
  646. REF(IUnknown*) pUnknown);
  648.     /************************************************************************
  649.      * Method:
  650.      *     IHXPlayer::SetClientContext
  651.      * Purpose:
  652.      *     Called by the client to install itself as the provider of client
  653.      *     services to the core. This is traditionally called by the top 
  654.      *     level client application.
  655.      */
  656.     STDMETHOD(SetClientContext) (THIS_
  657. IUnknown* pUnknown);
  659.     /************************************************************************
  660.      * Method:
  661.      *     IHXPlayer::GetClientContext
  662.      * Purpose:
  663.      *     Called by the get the client context for this player. This is 
  664.      *     traditionally to determine called by top level client application.
  665.      */
  666.     STDMETHOD(GetClientContext) (THIS_
  667. REF(IUnknown*) pUnknown);
  669.     /************************************************************************
  670.      * Method:
  671.      * IHXPlayer::IsDone
  672.      * Purpose:
  673.      * Ask the player if it is done with the current presentation
  674.      *
  675.      */
  676.     STDMETHOD_ (BOOL,IsDone) (THIS);
  678.     /************************************************************************
  679.      * Method:
  680.      * IHXPlayer::IsLive
  681.      * Purpose:
  682.      * Ask the player whether it contains the live source
  683.      *
  684.      */
  685.     STDMETHOD_ (BOOL,IsLive) (THIS);
  687.     /************************************************************************
  688.      * Method:
  689.      * IHXPlayer::GetCurrentPlayTime
  690.      * Purpose:
  691.      * Get the current time on the Player timeline
  692.      *
  693.      */
  694.     STDMETHOD_ (ULONG32,GetCurrentPlayTime) (THIS);
  696.     /************************************************************************
  697.      * Method:
  698.      *     IHXPlayer::AddAdviseSink
  699.      * Purpose:
  700.      *     Call this method to add a client advise sink.
  701.      *
  702.      */
  703.     STDMETHOD(AddAdviseSink) (THIS_
  704. IHXClientAdviseSink* pAdviseSink);
  706.     /************************************************************************
  707.      * Method:
  708.      *     IHXPlayer::RemoveAdviseSink
  709.      * Purpose:
  710.      *     Call this method to remove a client advise sink.
  711.      */
  712.     STDMETHOD(RemoveAdviseSink) (THIS_
  713. IHXClientAdviseSink* pAdviseSink);
  715.     /************************************************************************
  716.      * Method:
  717.      *     IHXPlayer2::SetMinimumPreroll
  718.      * Purpose:
  719.      *     Call this method to set the minimum preroll of this clip
  720.      */
  721.     STDMETHOD(SetMinimumPreroll) (THIS_
  722. UINT32 ulMinPreroll);
  724.     /************************************************************************
  725.      * Method:
  726.      *     IHXPlayer2::GetMinimumPreroll
  727.      * Purpose:
  728.      *     Call this method to get the minimum preroll of this clip
  729.      */
  730.     STDMETHOD(GetMinimumPreroll) (THIS_
  731. REF(UINT32) ulMinPreroll);
  733.     /************************************************************************
  734.      * Method:
  735.      *     IHXPlayer2::OpenRequest
  736.      * Purpose:
  737.      *     Call this method to open the IHXRequest
  738.      */
  739.     STDMETHOD(OpenRequest) (THIS_
  740.     IHXRequest* pRequest);
  741.     
  742.     /************************************************************************
  743.      * Method:
  744.      *     IID_IHXPlayer2::GetRequest
  745.      * Purpose:
  746.      *     Call this method to get the IHXRequest
  747.      */
  748.     STDMETHOD(GetRequest) (THIS_
  749.    REF(IHXRequest*) pRequest);
  751.     /************************************************************************
  752.      * Method:
  753.      *     EventOccurred
  754.      * Purpose:
  755.      *     Clients call this to pass OS events to the player. HXxEvent
  756.      *     defines a cross-platform event.
  757.      */
  758.     void EventOccurred(HXxEvent* pEvent);
  760. #ifdef _UNIX
  761.     void CollectSelectInfo(INT32 *n, 
  762.    fd_set* readfds,
  763.    fd_set* writefds, 
  764.    fd_set* exceptfds,
  765.    struct timeval* tv);
  766.     void ProcessSelect(INT32* n,
  767.        fd_set* readfds,
  768.        fd_set* writefds, 
  769.        fd_set* exceptfds,
  770.        struct timeval* tv);
  771. #endif
  773.     /************************************************************************
  774.      * Method:
  775.      * GetInst
  776.      * Purpose:
  777.      * TBD
  778.      *
  779.      */
  780.     ULONG32 GetInst(void);
  782.     /************************************************************************
  783.      * Method:
  784.      * UpdateStatistics
  785.      * Purpose:
  786.      * Update statistics periodically
  787.      *
  788.      */
  789.     HX_RESULT UpdateStatistics(void);
  791.     /************************************************************************
  792.      * Method:
  793.      * ProcessIdle
  794.      * Purpose:
  795.      * Work-Horse for the player...
  796.      *
  797.      */
  798.     HX_RESULT ProcessIdle(void);
  800.     /************************************************************************
  801.      *  Method:
  802.      *      IHXAudioPlayerResponse::OnTimeSync
  803.      *  Purpose:
  804.      *      Notification interface provided by users of the IHXAudioPlayer 
  805.      *      interface. This method is called by the IHXAudioPlayer when 
  806.      *      audio playback occurs.
  807.      */
  808.     STDMETHOD(OnTimeSync)       (THIS_
  809. ULONG32 /*IN*/ ulTimeEnd);
  812.     /************************************************************************
  813.      * Method:
  814.      * HXPlayer::Init
  815.      * Purpose:
  816.      * Get the interface to the client engine object of which the player
  817.      * is a part of. It is not a part of IHXPlayer interface
  818.      *
  819.      */
  820.     STDMETHOD(Init) (THIS_
  821.  IHXClientEngine* pEngine,
  822.  UINT32 unRegistryID,
  823.  CHXAudioPlayer* pAudioPlayer);
  825.     /************************************************************************
  826.      * Method:
  827.      * HXPlayer::ReportError
  828.      * Purpose:
  829.      * The source object reports of any fatal errors. 
  830.      *
  831.      */
  832.     void ReportError (HXSource* pSource, 
  833. HX_RESULT theErr, const char* pUserString = NULL);
  835.     // IHXPendingStatus methods
  837.     /************************************************************************
  838.      * Method:
  839.      *     IHXPendingStatus::GetStatus
  840.      * Purpose:
  841.      *     Called by the user to get the current pending status from an object
  842.      */
  843.     STDMETHOD(GetStatus) (THIS_
  844. REF(UINT16) uStatusCode, 
  845. REF(IHXBuffer*) pStatusDesc, 
  846. REF(UINT16) ulPercentDone);
  848.     /************************************************************************
  849.      * Method:
  850.      *     HXPlayer::SetStatsGranularity
  851.      * Purpose:
  852.      *     Called by the user to set how often the statistics registry needs 
  853.      *     to be updated in ms
  854.      */
  855.     STDMETHOD(SetStatsGranularity) (THIS_
  856. ULONG32 ulGranularity);
  858.     /************************************************************************
  859.      * Method:
  860.      *     IHXPlayerPresentation::ClosePresentation
  861.      * Purpose:
  862.      *     Call this method to close the player's current presentation.  This will free
  863.      *     all resources associated with the current presentation.
  864.      */
  865.     STDMETHOD(ClosePresentation)    (THIS);
  867.     /*
  868.      * IHXErrorMessages methods
  869.      */
  871.     /************************************************************************
  872.      * Method:
  873.      *     IHXErrorMessages::Report
  874.      * Purpose:
  875.      *     Call this method to report an error, event, or status message.
  876.      */
  877.     STDMETHOD(Report) (THIS_
  878. const UINT8 unSeverity,  
  879. HX_RESULT ulHXCode,
  880. const ULONG32 ulUserCode,
  881. const char* pUserString,
  882. const char* pMoreInfoURL
  883. );
  885.     /************************************************************************
  886.      * Method:
  887.      *     IHXErrorMessages::GetErrorText
  888.      * Purpose:
  889.      *     Call this method to get the text description of a RMA error code.
  890.      * Parameters:
  891.      *     HX_RESULT ulHXCode
  892.      *      A RMA error code.
  893.      *  Return Value:
  894.      *     IHXBuffer* containing error text.
  895.      */
  896.     STDMETHOD_(IHXBuffer*, GetErrorText) (THIS_
  897. HX_RESULT ulHXCode
  898. );
  900.     /*
  901.      * IHXRegistryID methods
  902.      */
  904.     /************************************************************************
  905.      * Method:
  906.      *     IHXRegistryID::GetID
  907.      * Purpose:
  908.      *     Get registry ID(hash_key) of the objects(player, source and stream)
  909.      *
  910.      */
  911.     STDMETHOD(GetID) (THIS_
  912. REF(UINT32) /*OUT*/  ulRegistryID);
  914.     STDMETHOD(HandleAuthenticationRequest) 
  915.                                      (IHXAuthenticationManagerResponse*);
  916.     STDMETHOD(HandleAuthenticationRequest2)
  917.          (IHXAuthenticationManagerResponse*, IHXValues*);
  919.     // IHXAuthenticationManagerResponse
  920.     STDMETHOD(AuthenticationRequestDone)
  921.     (
  922. HX_RESULT HX_RESULTStatus,
  923. const char* pcharUser,
  924. const char* pcharPassword
  925.     );
  926.     
  927.     /*
  928.      *  IHXGroupSink methods
  929.      */
  930.     /************************************************************************
  931.     *  Method:
  932.     *      IHXGroupSink::GroupAdded
  933.     *  Purpose:
  934.     * Notification of a new group being added to the presentation.
  935.     */
  936.     STDMETHOD(GroupAdded)    (THIS_
  937.     UINT16      /*IN*/ uGroupIndex,
  938.     IHXGroup*     /*IN*/ pGroup);
  940.     /************************************************************************
  941.     *  Method:
  942.     *      IHXGroupSink::GroupRemoved
  943.     *  Purpose:
  944.     * Notification of a group being removed from the presentation.
  945.     */
  946.     STDMETHOD(GroupRemoved)    (THIS_
  947. UINT16      /*IN*/ uGroupIndex,
  948. IHXGroup*  /*IN*/ pGroup);
  950.     /************************************************************************
  951.     *  Method:
  952.     *      IHXGroupSink::AllGroupsRemoved
  953.     *  Purpose:
  954.     * Notification that all groups have been removed from the 
  955.     * current presentation.
  956.     */
  957.     STDMETHOD(AllGroupsRemoved)  (THIS);
  959.     /************************************************************************
  960.     *  Method:
  961.     *      IHXGroupSink::TrackAdded
  962.     *  Purpose:
  963.     * Notification of a new track being added to a group.
  964.     */
  965.     STDMETHOD(TrackAdded)  (THIS_
  966.     UINT16      /*IN*/ uGroupIndex,
  967.     UINT16      /*IN*/ uTrackIndex,
  968.     IHXValues*     /*IN*/ pTrack);
  970.     /************************************************************************
  971.     *  Method:
  972.     *      IHXGroupSink::TrackAdded
  973.     *  Purpose:
  974.     * Notification of a track being removed from a group.
  975.     */
  976.     STDMETHOD(TrackRemoved)    (THIS_
  977. UINT16  /*IN*/ uGroupIndex,
  978. UINT16  /*IN*/ uTrackIndex,
  979. IHXValues* /*IN*/ pTrack);
  981.     /************************************************************************
  982.     *  Method:
  983.     *      IHXGroupSink::TrackStarted
  984.     *  Purpose:
  985.     * Notification of a track being started in a group.
  986.     */
  987.     STDMETHOD(TrackStarted)    (THIS_
  988. UINT16  /*IN*/ uGroupIndex,
  989. UINT16  /*IN*/ uTrackIndex,
  990. IHXValues* /*IN*/ pTrack);
  992.     /************************************************************************
  993.     *  Method:
  994.     *      IHXGroupSink::TrackStopped
  995.     *  Purpose:
  996.     * Notification of a track being stopped in a group.
  997.     */
  998.     STDMETHOD(TrackStopped)    (THIS_
  999. UINT16  /*IN*/ uGroupIndex,
  1000. UINT16  /*IN*/ uTrackIndex,
  1001. IHXValues* /*IN*/ pTrack);
  1003.    /************************************************************************
  1004.     *  Method:
  1005.     *      IHXGroupSink::CurrentGroupSet
  1006.     *  Purpose:
  1007.     * This group is being currently played in the presentation.
  1008.     */
  1009.     STDMETHOD(CurrentGroupSet) (THIS_
  1010. UINT16      /*IN*/ uGroupIndex,
  1011. IHXGroup*  /*IN*/ pGroup);
  1012.            
  1013.     /*
  1014.      * IHXLayoutSiteGroupManager methods
  1015.      */
  1016.     /************************************************************************
  1017.     *  Method:
  1018.     *      IHXLayoutSiteGroupManager::AddLayoutSiteGroup
  1019.     *  Purpose:
  1020.     * Add this LSG to the presentation
  1021.     */
  1022.     STDMETHOD(AddLayoutSiteGroup) (THIS_
  1023. IUnknown*  /*IN*/ pLSG);
  1025.     /************************************************************************
  1026.     *  Method:
  1027.     *      IHXLayoutSiteGroupManager::RemoveLayoutSiteGroup
  1028.     *  Purpose:
  1029.     * Remove this LSG from the presentation
  1030.     */
  1031.     STDMETHOD(RemoveLayoutSiteGroup) (THIS_
  1032. IUnknown*  /*IN*/ pLSG);
  1034.     /*
  1035.      * IHXRendererUpgrade methods
  1036.      */
  1037.     /************************************************************************
  1038.     *  Method:
  1039.     *      IHXRendererUpgrade::IsRendererAvailable
  1040.     *  Purpose:
  1041.     *    Is a renderer with this mime type already loaded?
  1042.     */
  1043.     STDMETHOD_(BOOL,IsRendererAvailable)(THIS_
  1044. const char* /*IN*/ pMimeType);
  1046.     /************************************************************************
  1047.     *  Method:
  1048.     *      IHXRendererUpgrade::ForceUpgrade
  1049.     *  Purpose:
  1050.     *    Force an upgrade of all renderers in list
  1051.     */
  1052.     STDMETHOD(ForceUpgrade) (THIS);
  1054.     /*
  1055.      * IHXInternalReset method
  1056.      */
  1057.     STDMETHOD(InternalReset) (THIS);
  1059.     /*
  1060.      * IHXPlayerState methods
  1061.      */
  1062.     STDMETHOD_(BOOL, IsPlaying)    (THIS) {return m_bIsPlaying;}
  1064.     /************************************************************************
  1065.      *  IHXViewSourceCommand methods
  1066.      */
  1067.     STDMETHOD_(BOOL, CanViewSource) (THIS_  
  1068. IHXStreamSource* pStream);
  1069.     STDMETHOD(DoViewSource) (THIS_
  1070. IHXStreamSource* pStream);
  1071.     STDMETHOD(GetViewSourceURL) (THIS_
  1072. IHXStreamSource*     pSource,
  1073. IHXViewSourceURLResponse*  pResp);
  1075.     /*
  1076.      * IHXOverrideDefaultServices methods
  1077.      */
  1079.     /************************************************************************
  1080.      *  Method:
  1081.      *      IHXOverrideDefaultServices::OverrideServices
  1082.      *  Purpose:
  1083.      *      Override default services provided by the G2 system.
  1084.      * 
  1085.      */
  1086.     STDMETHOD(OverrideServices)         (THIS_
  1087. IUnknown* pContext);
  1089.     /*
  1090.      * IHXPlayerNavigator methods
  1091.      */
  1093.     /************************************************************************
  1094.      * Method:
  1095.      *     IHXPlayerNavigator::AddChildPlayer
  1096.      * Purpose:
  1097.      *     Add child player to the current player
  1098.      */
  1099.     STDMETHOD(AddChildPlayer)     (THIS_
  1100.     IHXPlayer* pPlayer);
  1102.     /************************************************************************
  1103.      * Method:
  1104.      *     IHXPlayerNavigator::RemoveChildPlayer
  1105.      * Purpose:
  1106.      *     Remove child player from the current player
  1107.      */
  1108.     STDMETHOD(RemoveChildPlayer)    (THIS_
  1109.     IHXPlayer* pPlayer);
  1111.     /************************************************************************
  1112.      * Method:
  1113.      *     IHXPlayerNavigator::GetNumChildPlayer
  1114.      * Purpose:
  1115.      *     Get number of the child players
  1116.      */
  1117.     STDMETHOD_(UINT16, GetNumChildPlayer)    (THIS);
  1119.     /************************************************************************
  1120.      * Method:
  1121.      *     IHXPlayerNavigator::GetChildPlayer
  1122.      * Purpose:
  1123.      *     Get Nth child player
  1124.      */
  1125.     STDMETHOD(GetChildPlayer)     (THIS_
  1126.     UINT16 uPlayerIndex,
  1127.     REF(IHXPlayer*) pPlayer);
  1129.     /************************************************************************
  1130.      * Method:
  1131.      *     IHXPlayerNavigator::SetParentPlayer
  1132.      * Purpose:
  1133.      *     Set the parent player
  1134.      */
  1135.     STDMETHOD(SetParentPlayer)     (THIS_
  1136.     IHXPlayer* pPlayer);
  1138.     /************************************************************************
  1139.      * Method:
  1140.      *     IHXPlayerNavigator::RemoveParentPlayer
  1141.      * Purpose:
  1142.      *     Remove the parent player
  1143.      */
  1144.     STDMETHOD(RemoveParentPlayer)   (THIS_
  1145.     IHXPlayer* pPlayer);
  1147.     /************************************************************************
  1148.      * Method:
  1149.      *     IHXPlayerNavigator::GetParentPlayer
  1150.      * Purpose:
  1151.      *     Get the parent player
  1152.      */
  1153.     STDMETHOD(GetParentPlayer)     (THIS_
  1154.     REF(IHXPlayer*) pPlayer);
  1156.     /* 
  1157.      * IHXRecordManager methods 
  1158.      */ 
  1160.     /************************************************************************ 
  1161.      *  Method: 
  1162.      *      IHXRecordManager::LoadRecordService 
  1163.      *  Purpose: 
  1164.      *      Called by TLC to supply the Core with record service. 
  1165.      */ 
  1166.     STDMETHOD(LoadRecordService) (THIS_ IHXRecordService* pRecordService); 
  1168.     /************************************************************************ 
  1169.      *  Method: 
  1170.      *      IHXRecordManager::GetRecordService 
  1171.      *  Purpose: 
  1172.      *      return current record service for the Player. 
  1173.      */ 
  1174.     STDMETHOD(GetRecordService) (THIS_ REF(IHXRecordService*) pRecordService); 
  1176.     /************************************************************************ 
  1177.      *  Method: 
  1178.      *      IHXRecordManager::UnloadRecordService 
  1179.      *  Purpose: 
  1180.      *      Called by TLC to ask the Core to stop using record service. 
  1181.      */ 
  1182.     STDMETHOD(UnloadRecordService) (THIS); 
  1184.     ////////////////////////////////////////////////////////////////////
  1185.     //
  1186.     // The following members are related to meta-file support.
  1187.     //
  1188. public:
  1189.     void SetModal(BOOL bModal) {m_bSetModal = bModal;};
  1190.     HX_RESULT SetSingleURLPresentation(const CHXURL* pURL);
  1192.     HX_RESULT AddURL(SourceInfo*& pSourceInfo, BOOL bAltURL);
  1194.     void GetActiveRequest(IHXRequest*& pRequest)
  1195. {
  1196.     pRequest = NULL;     
  1198.     if (m_pRequest)
  1199.     {
  1200. #if defined(HELIX_FEATURE_NESTEDMETA)
  1201. // we want to keep the original copy of IHXRequest in SMIL/RAM
  1202. // so that individual source within will have a "clean" copy of 
  1203. // IHXRequest to start with
  1204. if (m_pPersistentComponentManager &&
  1205.     m_pPersistentComponentManager->m_pRootPersistentComponent &&
  1206.     !m_pPersistentComponentManager->m_pRootPersistentComponent->m_bToBeClosed)
  1207. {
  1208.     CHXRequest::CreateFromWithRequestHeaderOnly(m_pRequest, &pRequest);
  1209. }
  1210. else
  1211. #endif /* HELIX_FEATURE_NESTEDMETA */
  1212. if (m_bActiveRequest)
  1213. {
  1214.     pRequest = m_pRequest;
  1215.     pRequest->AddRef();
  1216. }
  1217.     }
  1218. };
  1220.     void ResetActiveRequest() {m_bActiveRequest = FALSE;};
  1222.     void SetGranularity(ULONG32 ulGranularity);
  1223.     ULONG32 GetGranularity(void) {return m_ulLowestGranularity;};
  1225.     HX_RESULT SetGranularity(HXSource* pSource, UINT16 uStreamNumber, 
  1226.        UINT32 ulGranularity);
  1228.     void                ClosePlayer(void);
  1229.     
  1230.     void InternalPause();
  1232.     HX_RESULT EventReady(HXSource* pSource, CHXEvent* pEvent);
  1234.     void ShutDown(void);
  1236.     void RegisterSourcesDone(void);
  1238.     BOOL IsInitialized(void) {return m_bInitialized;};
  1240.     BOOL CanBeStarted(HXSource* pSource, SourceInfo* pThisSourceInfo, BOOL bPartOfNextGroup);
  1241.     void EndOfSource(HXSource* pSource);
  1243.     BOOL CanBeFastStarted(SourceInfo* pSourceInfo);
  1244.     void SureStreamSourceRegistered(SourceInfo* pSourceInfo);
  1245.     void SureStreamSourceUnRegistered(SourceInfo* pSourceInfo);
  1247.     ULONG32 GetInternalCurrentPlayTime(void)
  1248.     { return m_ulCurrentPlayTime; };
  1250.     HX_RESULT HandleRedirectRequest(UINT16 nGroup, UINT16 nTrack, char* pURL);
  1251.     BOOL IsAtSourceMap(SourceInfo* pSourceInfo);
  1253.     HX_RESULT RepeatTrackAdded(UINT16 /*IN*/ uGroupIndex,
  1254.  UINT16 /*IN*/ uTrackIndex,
  1255.  IHXValues* /*IN*/ pTrack);
  1257.     /* Temporary function */
  1258.     void SetInterrupt(BOOL bUseCoreThread) 
  1259.     {m_bUseCoreThread = bUseCoreThread;};
  1260.     virtual HX_RESULT SendPacket(CHXEvent* pEvent);
  1261.     CHXAudioPlayer* GetAudioPlayer(void) {return m_pAudioPlayer;};
  1262.     INT32 GetCurrentGroupID(void) {return m_nCurrentGroup;};
  1263.     void                NotifyPlaybackEndToTLC() {m_bIsPresentationClosedToBeSent = TRUE;};
  1264.     HX_RESULT CopyRegInfo(UINT32 ulFromRegID, UINT32 ulToRegID);
  1266.     BOOL                IsSitePresent(IHXSite* pSite);
  1267.     void CheckIfRendererNeedFocus(IUnknown* pRenderer);
  1269.     static void         PlayerCallback(void *pParam);
  1270.     static void SetupCallback(void *pParam);
  1271. #if defined(HELIX_FEATURE_AUTHENTICATION)
  1272.     static void         AuthenticationCallback(void *pParam);
  1273. #endif
  1274.     
  1275.     friend class SourceInfo;
  1276.     friend class HXSource;
  1277.     friend class HXNetSource;
  1278.     friend class HXFileSource;
  1279.     friend class HXPersistentComponent;
  1280.     friend class HXPersistentComponentManager;
  1282. private:
  1283.     HX_BITFIELD m_bForceStatsUpdate : 1;
  1284.     HX_BITFIELD m_bActiveRequest : 1;
  1285.     HX_BITFIELD m_bAddLayoutSiteGroupCalled : 1;
  1286.     HX_BITFIELD m_bDoRedirect : 1;
  1287.     HX_BITFIELD m_bFastStartCheckDone : 1;
  1288.     HX_BITFIELD m_bFastStart : 1;
  1290.     TurboPlayOffReason m_turboPlayOffReason;
  1292.     UINT32 m_ulActiveSureStreamSource;
  1294.     INT32 m_nCurrentGroup;
  1295.     INT32 m_nGroupCount;
  1297.     HX_RESULT DoOpenGroup(UINT16 nGroupNumber);
  1298.     HX_RESULT OpenTrack(IHXValues* pTrack, UINT16 uGroupID, UINT16 uTrackID);
  1299.     void PlayNextGroup();
  1301.     BOOL CheckTrackAndSourceOnTrackStarted(INT32 nGroup, INT32 nTrack, UINT32 sourceID);
  1303.     BOOL GetViewSourceStream(REF(IHXStreamSource*) pStrmSource);
  1304.     BOOL AreAllPacketsSent();
  1306.     HX_RESULT GetSourceInfo(UINT16 uGroupIndex, UINT16 uTrackIndex, SourceInfo*& pSourceInfo);
  1307.     HX_RESULT UpdateTrack(UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pValues);
  1308.     HX_RESULT RemoveTrack(UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pValues);
  1309.     HX_RESULT AddPrefetchTrack(UINT16 uGroupIndex, UINT16 uPrefetchTrackIndex, IHXValues* pValues);
  1310.     HX_RESULT UpdatePrefetchTrack(UINT16 uGroupIndex, UINT16 uPrefetchTrackIndex, IHXValues* pValues);
  1311.     HX_RESULT RemovePrefetchTrack(UINT16 uGroupIndex, UINT16 uPrefetchTrackIndex, IHXValues* pValues);
  1312.     HX_RESULT PrefetchTrackDone(UINT16 uGroupIndex, UINT16 uPrefetchTrackIndex, HX_RESULT status);
  1314.     HX_RESULT BeginTrack(UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pValues);    
  1315.     HX_RESULT PauseTrack(UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pValues);
  1316.     HX_RESULT SeekTrack(UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pValues, UINT32 ulSeekTime);    
  1317.     HX_RESULT StopTrack(UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pValues);    
  1318.     HX_RESULT SetSoundLevel(UINT16 uGroupIndex, UINT16 uTrackIndex, UINT16 uSoundLevel, BOOL bReflushAudioDevice);    
  1320.     void                CheckSourceRegistration(void);
  1321.     void                GetTimingFromURL(CHXURL* pURL, UINT32& ulStart, UINT32& ulEnd, UINT32& ulDelay, UINT32& ulDuration);
  1323. #if defined(HELIX_FEATURE_RECORDCONTROL)
  1324.     BOOL                IsRecordServiceEnabled();
  1325. #endif
  1327. protected:
  1328.     CHXSimpleList* m_pAltURLs;
  1329.     CHXURL* m_pURL;
  1330.     IHXRequest* m_pRequest;
  1332.     HX_RESULT AdjustSeekOnRepeatedSource(SourceInfo* pSourceInfo, 
  1333.    UINT32 ulSeekTime);
  1335.     HX_RESULT  DoNetworkOpen(SourceInfo*& pSourceInfo, BOOL bAltURL);
  1336.     HX_RESULT  DoFileSystemOpen(SourceInfo*& pSourceInfo, BOOL bAltURL);
  1338.     HX_RESULT CreateSourceInfo(SourceInfo*& pSourceInfo, BOOL bAltURL);
  1339.     HX_RESULT PrepareSourceInfo(IHXValues* pTrack, SourceInfo*& pSourceInfo);
  1340.     HX_RESULT DoURLOpen(CHXURL* pURL, char* pMimeType);
  1341.     HX_RESULT DoAltURL(void);
  1342.     HX_RESULT DoAltURLOpen(char* pURL, BOOL bDefault, SourceInfo* pMainSourceInfo);
  1343.     HX_RESULT SpawnSourceIfNeeded(SourceInfo* pSourceInfo);
  1344.     HX_RESULT SwitchSourceIfNeeded(void);
  1346.     HX_RESULT DoRedirect(void);
  1347.     HX_RESULT OpenRedirect(const char* pszURL);
  1349.     HX_RESULT InitializeRenderers(void);
  1351.     HX_RESULT LayoutRenderers(void);
  1352.     virtual HX_RESULT ProcessIdleExt(void);
  1354.     void CreateDefaultRendererWindow
  1355.     (
  1356. RendererInfo*     pRInfo,
  1357. IHXRenderer*     pRend,
  1358. IHXBuffer*     pDisplayInfo,
  1359. const char*     pName
  1360.     );
  1361.     void CreateLayoutWindow
  1362.     (
  1363. IHXMetaLayout* pLayout
  1364.     );
  1366.     /************************************************************************
  1367.      * Method:
  1368.      * ExecuteCurrentEvents
  1369.      * Purpose:
  1370.      * Send any due packets to the renderers
  1371.      *
  1372.      */
  1373.     HX_RESULT ProcessCurrentEvents(void);
  1375.     /************************************************************************
  1376.      * Method:
  1377.      * DeleteAllEvents
  1378.      * Purpose:
  1379.      * Remove all pending events due to seek/stop.
  1380.      *
  1381.      */
  1382.     HX_RESULT DeleteAllEvents(void);
  1383.     HX_RESULT SendPreSeekEvents(void);
  1384.     void StopAllStreams(EndCode endCode = END_STOP);
  1385.     
  1386.     virtual HX_RESULT SendPreSeekEventsExt(void);         
  1387.     virtual HX_RESULT StopAllStreamsExt(EndCode endCode = END_STOP);
  1388.     
  1389.     virtual SourceInfo*     NewSourceInfo(void);
  1390.     virtual HXFileSource*  NewFileSource(void);
  1391.     virtual HXNetSource*   NewNetSource(void);
  1392.     virtual HX_RESULT     OpenTrackExt(void);
  1394.     void CloseAllRenderers(INT32 nGroupSwitchTo);
  1395.     HX_RESULT UnRegisterCurrentSources(void);
  1397.     HX_RESULT SetupAllStreams(void);
  1398.     void ResetPlayer(void);
  1399.     void ResetGroup(void);
  1400.     void SetMinimumPushdown(void);
  1401.     void SchedulePlayer(void);
  1402.     HX_RESULT CheckForAudioResume(void);
  1404.     HX_RESULT InitializeNetworkDrivers(void);
  1406.     inline void UpdateCurrentPlayTime( ULONG32 ulCurrentPlayTime );
  1407.     
  1408.     HX_RESULT ActualReport(
  1409.     const UINT8 unSeverity,  
  1410.     HX_RESULT ulHXCode,
  1411.     const ULONG32 ulUserCode,
  1412.     const char* pUserString,
  1413.     const char* pMoreInfoURL);
  1415.     IHXPendingStatus* m_pMetaSrcStatus;
  1417.     // list of sources
  1418.     CHXMapPtrToPtr* m_pSourceMap;
  1419.     CHXSimpleList* m_pPendingTrackList;
  1421.     // current time on the timeline for this player..
  1422.     // this would either be updated by the audio services of any rendering object
  1423.     // happens to be an audio renderer and decides to use our audio services...
  1424.     // ELSE it will be updated by a timer object... 
  1425.     ULONG32 m_ulCurrentPlayTime;
  1426.     
  1427. #if defined(_MACINTOSH) || defined(_MAC_UNIX)
  1428.     // this tracks the current timeline for this player, with the caveat
  1429.     // that it's only updated when the current play time is updated at
  1430.     // system time. This is useful for deciding whether to allocated "extra"
  1431.     // time to the player or giving it back to the system -- a pretty
  1432.     // complicated issue on MacOS 8.
  1433.     ULONG32 m_ulCurrentSystemPlayTime;
  1434. #endif
  1436.     
  1437.     // Length of all sources!
  1438.     ULONG32 m_ulPresentationDuration;
  1440.     // used to inform renderers the pre and post seek info..
  1441.     ULONG32 m_ulTimeBeforeSeek;
  1442.     ULONG32 m_ulTimeAfterSeek;
  1445.     BufferingReason m_BufferingReason;
  1447.     CHXEventList m_EventList; // contains packets for all streams
  1449.     IHXScheduler* m_pScheduler;
  1451.     /* m_uNumSourcesActive gets decremented when we have sucked out all the packets
  1452.      * from the source 
  1453.      */
  1454.     UINT16 m_uNumSourcesActive : 16;
  1456.     /* m_uNumCurrentSourceNotDone gets decremented when a given source has received
  1457.      * all the packets from the server
  1458.      */
  1459.     UINT16 m_uNumCurrentSourceNotDone : 16;
  1461.     HX_BITFIELD m_bSourceMapUpdated : 1;
  1462.     HX_BITFIELD m_bInitialized : 1;
  1463.        
  1464.     // m_bIsDone: single presentation/individual group in a SMIL file
  1465.     // m_bIsPresentationDone: single/SMIL presentation
  1466.     HX_BITFIELD m_bIsDone : 1;
  1467.     HX_BITFIELD m_bIsPresentationDone : 1;
  1468.     HX_BITFIELD m_bInStop : 1;
  1469.     HX_BITFIELD m_bIsPresentationClosedToBeSent : 1;
  1470.     HX_BITFIELD m_bCloseAllRenderersPending : 1;
  1472.     HX_BITFIELD m_bUseCoreThread : 1;
  1473.     HX_BITFIELD m_bCoreLocked : 1;
  1474.     HX_BITFIELD m_bPaused : 1;
  1475.     HX_BITFIELD m_bBeginPending : 1;
  1477.     HX_BITFIELD m_bIsFirstBeginPending : 1;
  1479.     HX_BITFIELD m_bIsFirstBegin : 1;
  1481.     HX_BITFIELD m_bUserHasCalledBegin : 1;
  1483.     HX_BITFIELD m_bTimelineToBeResumed : 1;
  1484.     HX_BITFIELD m_bIsPlaying : 1;
  1486.     HX_BITFIELD m_bNetInitialized : 1;
  1487.     HX_BITFIELD m_bPrefTransportInitialized : 1;
  1489.     HX_BITFIELD m_bSetupLayoutSiteGroup : 1;
  1490.     
  1491.     HX_BITFIELD m_bTimeSyncLocked : 1;
  1493.     HX_BITFIELD m_bIsLive : 1;
  1494.     HX_BITFIELD m_bLiveSeekToBeDone : 1;
  1496.     HX_BITFIELD m_bProcessEventsLocked : 1;
  1497.     HX_BITFIELD m_bDidWeDeleteAllEvents : 1;
  1499.     ULONG32 m_ulLowestGranularity;
  1500.     UINT32 m_ulElapsedPauseTime;
  1501.     UINT32 m_ulLiveSeekTime;
  1502.     UINT32 m_ulTimeOfPause;
  1503.     UINT32 m_ulMinimumAudioPreroll;
  1504.     UINT32 m_ulMinimumTotalPreroll;
  1505.     
  1506.     friend class HXPlayerCallback;
  1508. //#if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  1509.     friend class UpdateStatsCallback;
  1510. //#endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  1512.     /* Used for multiple kive stream synchrnoization*/
  1513.     UINT32 m_ulFirstTimeSync;
  1515.     UINT32 m_ulFSBufferingEndTime;
  1516.     UINT16 m_uNumSourceToBeInitializedBeforeBegin : 16;
  1518.     HX_BITFIELD m_bFastStartInProgress : 1;
  1519.     HX_BITFIELD m_bIsFirstTimeSync : 1;
  1520.     HX_BITFIELD m_bPlayerWithoutSources : 1;
  1521.     HX_BITFIELD m_bInternalPauseResume : 1;
  1522.     HX_BITFIELD m_bInternalReset : 1;
  1523.     HX_BITFIELD m_bCurrentPresentationClosed : 1;
  1524.     HX_BITFIELD m_bContactingDone : 1;
  1525.     HX_BITFIELD m_bFSBufferingEnd : 1;
  1526.     HX_BITFIELD m_bAllLocalSources : 1;
  1527.     HX_BITFIELD m_b100BufferingToBeSent : 1;
  1528.     HX_BITFIELD m_bSetupToBeDone : 1;
  1529.     HX_BITFIELD m_bPostSetupToBeDone : 1;
  1530.     HX_BITFIELD m_bInternalReportError : 1;
  1531.     HX_BITFIELD m_bPartOfNextGroup : 1;   
  1532.     HX_BITFIELD m_bLastGroup : 1;
  1533.     HX_BITFIELD m_bNextGroupStarted : 1;
  1534.     HX_BITFIELD m_bBeginChangeLayoutTobeCalled : 1;
  1535.     HX_BITFIELD m_bPendingAudioPause : 1;
  1536.     HX_BITFIELD m_bPlayStateNotified : 1;
  1537.     HX_BITFIELD m_bResumeOnlyAtSystemTime : 1;
  1538.     HX_BITFIELD m_bSetModal : 1;
  1540. #if defined(HELIX_FEATURE_PREFETCH)
  1541.     PrefetchManager* m_pPrefetchManager;
  1542. #else
  1543.     void* m_pPrefetchManager;
  1544. #endif /* HELIX_FEATURE_PREFETCH */
  1546. #ifdef _WIN32
  1547.     BOOL m_bScreenSaverActive; 
  1548. #endif
  1550. #if defined(HELIX_FEATURE_NEXTGROUPMGR)
  1551.     NextGroupManager* m_pNextGroupManager;
  1552. #else
  1553.     void* m_pNextGroupManager;
  1554. #endif /* HELIX_FEATURE_NEXTGROUPMGR*/
  1556.     IHXGroup* m_pCurrentGroup;
  1558.     IHXPlayer* m_pParentPlayer;
  1559.     CHXSimpleList* m_pChildPlayerList;
  1561. #if defined(HELIX_FEATURE_ASM)
  1562.     IHXBandwidthManager* m_pBandwidthMgr;
  1563.     /* Only used for load testing */
  1564.     IHXBandwidthManager* m_pASM;
  1565. #endif /* HELIX_FEATURE_ASM */
  1567.     CHXSimpleList m_ToBeginRendererList;
  1568.     void EnterToBeginList(RendererInfo* pRendInfo);
  1569.     void EmptyBeginList(void) {m_ToBeginRendererList.RemoveAll();};
  1570.     HX_RESULT CheckBeginList(void);
  1571.     void RemoveFromPendingList(RendererInfo* pRendInfo);
  1573.     void CheckToStartNextGroup(void);
  1574.     void AdjustPresentationTime(void);
  1575.     void SetPresentationTime(UINT32 ulPresentationTime);
  1577.     void UpdateSourceActive(void);
  1578.     HX_RESULT UpdateSourceInfo(SourceInfo* pSourceInfo, 
  1579.  UINT32 ulParentRegId,
  1580.  UINT16 ulTrackIndex);
  1581.     HX_RESULT UpdatePersistentSrcInfo(SourceInfo* pSourceInfo, 
  1582.                                                 UINT32 ulParentRegId,
  1583.                                                 UINT16 ulTrackIndex);
  1585.     /*
  1586.      * The following members are related to the new layout support.
  1587.      */
  1588. #if defined(HELIX_FEATURE_VIDEO)
  1589.     CHXSiteManager* m_pSiteManager;
  1590.     IHXSiteSupplier* m_pSiteSupplier;
  1591. #else
  1592.     void* m_pSiteManager;
  1593.     void* m_pSiteSupplier;
  1594. #endif /* HELIX_FEATURE_VIDEO */
  1596.     CHXSimpleList m_SiteRequestIDList;
  1597.     
  1598.     void SetupRendererSite(IUnknown* pRenderer, IHXValues* pProps, BOOL bIsPersistent);
  1599.     void SetupLayoutSiteGroup(IUnknown* pLSG, BOOL bIsPersistent);
  1600.     STDMETHODIMP SetupLayout(BOOL bIsPersistent);
  1601.     STDMETHODIMP CleanupLayout(void);
  1603.     HX_RESULT StartDownload(void);
  1604.     HX_RESULT PauseDownload(void);
  1605.     void UnregisterNonActiveSources();
  1606.     BOOL AreAllSourcesSeekable(void);
  1607.     void ResetError(void);
  1608.     void ResetRedirectList(void);
  1609.     void SetLastError(HX_RESULT theErr);
  1611.     void Close();
  1612.     void AbortPlayer(void);
  1613.     void StopPlayer(EndCode endCode = END_STOP);
  1614.     HX_RESULT PausePlayer(BOOL bNotifyTLC = TRUE);
  1615.     HX_RESULT SeekPlayer(ULONG32 ulTime);
  1616.     HX_RESULT BeginPlayer(void);
  1618.     HX_RESULT SetupAudioPlayer(void);
  1619.     virtual HX_RESULT PrepareAudioPlayer(void);
  1621. //#if defined(HELIX_FEATURE_AUTHENTICATION)
  1622.     void ProcessPendingAuthentication();
  1623.     void ClearPendingAuthenticationRequests();
  1624. //#endif /* HELIX_FEATURE_AUTHENTICATION */
  1626.     void SendPostSeekIfNecessary(RendererInfo* pRendererInfo);
  1628.     BOOL ScheduleOnTimeSync(void);
  1629.     BOOL DurationTimeSyncAllSent(SourceInfo* pSourceInfo);
  1630.     virtual void DisableScreenSaver();
  1631.     void                RemovePendingCallback(CHXGenericCallback* pCB);
  1633. #if defined(HELIX_FEATURE_AUTOUPGRADE)
  1634.     IHXUpgradeCollection* m_pUpgradeCollection;
  1635. #else
  1636.     void* m_pUpgradeCollection;
  1637. #endif /* HELIX_FEATURE_AUTOUPGRADE */
  1639.     friend class NextGroupManager;
  1641. //#if defined(HELIX_FEATURE_PREFETCH)
  1642.     friend class PrefetchManager;
  1643. //#endif /* HELIX_FEATURE_PREFETCH */
  1644.     
  1645.     // used to notify of changes to the precache group
  1646. #if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
  1647.     friend class HXAdvancedGroup;    
  1648.     friend class HXAdvancedGroupManager;    
  1649. #endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */
  1651. #if defined(HELIX_FEATURE_BASICGROUPMGR)
  1652.     friend class HXBasicGroup;
  1653.     friend class HXBasicGroupManager;
  1654. #endif /* HELIX_FEATURE_BASICGROUPMGR */
  1656.     HX_RESULT NextGroupSet(UINT16 uGroupIndex);
  1658. //#if defined(HELIX_FEATURE_AUTHENTICATION)
  1659. #ifndef _WIN16
  1660.     // Store pending requests
  1661.     friend class _CHXAuthenticationRequests;
  1662.     _CHXAuthenticationRequests m_AuthenticationRequestsPending;
  1663. #endif /* _WIN16 */
  1664. //#endif /* HELIX_FEATURE_AUTHENTICATION */
  1666.     HXMutex* m_pCoreMutex;
  1668.     /*
  1669.      * -- LIVE SYNC SUPPORT --
  1670.      *
  1671.      * The following is related to shared wall clock support
  1672.      * for syncronizing several live sources. See srcinfo.cpp
  1673.      * for more informantion.
  1674.      */
  1675. private:
  1676.     CHXMapStringToOb* m_pSharedWallClocks;
  1677.     friend class SharedWallClock;
  1679.     IHXRecordService* m_pRecordService;
  1680.     BOOL                m_bRecordServiceEnabled;
  1682. public:
  1683.     BOOL FindSharedWallClocks(const char* pClockName, void*& ppValue)
  1684.     {
  1685. return m_pSharedWallClocks->Lookup(pClockName,ppValue);
  1686.     };
  1687. };
  1689. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  1690. class UpdateStatsCallback : public IHXCallback
  1691. {
  1692. public:
  1693.     HXPlayer* m_pPlayer;
  1694.     CallbackHandle m_PendingHandle;
  1695.     BOOL m_bIsCallbackPending;
  1697. UpdateStatsCallback();
  1698.     /*
  1699.      * IUnknown methods
  1700.      */
  1701.     STDMETHOD(QueryInterface) (THIS_
  1702.     REFIID riid,
  1703.     void** ppvObj);
  1705.     STDMETHOD_(ULONG32,AddRef) (THIS);
  1707.     STDMETHOD_(ULONG32,Release) (THIS);
  1709.     /*
  1710.      * IHXCallback methods
  1711.      */
  1712.     STDMETHOD(Func) (THIS);
  1714. protected:
  1715. ~UpdateStatsCallback();
  1717.     LONG32 m_lRefCount;
  1718. };
  1719. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  1721. #if defined (_WIN32) || defined (_MACINTOSH) || defined(THREADS_SUPPORTED)
  1722. class HXPlayerCallback : public CHXGenericCallback
  1723.                        , public IHXInterruptSafe
  1724. {
  1725. public:    
  1726.     BOOL m_bInterrupSafe;
  1728.     HXPlayerCallback(void* pParam, fGenericCBFunc pFunc);
  1729.     
  1730.     STDMETHOD_(ULONG32,AddRef) (THIS) {return CHXGenericCallback::AddRef();}
  1731.     STDMETHOD_(ULONG32,Release) (THIS) {return CHXGenericCallback::Release();}
  1732.     STDMETHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj);
  1734.     STDMETHOD_(BOOL,IsInterruptSafe) (THIS);
  1736. protected:
  1737.     ~HXPlayerCallback() {};
  1738. };
  1739. #endif //(_WIN32) || defined (_MACINTOSH) || defined(THREADS_SUPPORTED)
  1741. #endif //_HXPLAYER_