hxplay.h

linux下的一款播放器

    ~PendingTrackInfo()
    {
	HX_RELEASE(m_pTrack);
    }

    UINT16 	  m_uGroupIndex;
    UINT16 	  m_uTrackIndex;
    IHXValues*   m_pTrack;
};
#endif /* _WIN16 */

class HXPlayer :   public IHXPlayer, 
		    public IHXPlayer2,
		    public IHXAudioPlayerResponse,
		    public IHXPendingStatus,
		    public IHXErrorMessages,
		    public IHXAuthenticationManager,
		    public IHXAuthenticationManager2,
		    public IHXAuthenticationManagerResponse,
		    public IHXRegistryID,
		    public IHXGroupSink,
		    public IHXLayoutSiteGroupManager,
		    public IHXRendererUpgrade,
		    public IHXInternalReset,
		    public IHXPlayerState,
		    public IHXViewSourceCommand,
		    public IHXOverrideDefaultServices,
		    public IHXPlayerNavigator,
		    public IHXClientStatisticsGranularity,
		    public IHXPlayerPresentation,
                    public IHXRecordManager
{
protected:
    LONG32			m_lRefCount;
    UINT32			m_ulRepeatedRegistryID;
    UINT32			m_ulNextGroupRegistryID;
    HX_RESULT			m_LastError;
    char*			m_pLastUserString;
    UINT8			m_LastSeverity;
    UINT32			m_ulLastUserCode;
    char*			m_pLastMoreInfoURL;

#if defined(HELIX_FEATURE_REGISTRY)    
    // statistic variables
    HXClientRegistry*		m_pRegistry;
#else
    void*			m_pRegistry;
#endif /* HELIX_FEATURE_REGISTRY */

#if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
    PLAYER_STATS*		m_pStats;
    UpdateStatsCallback*	m_pUpdateStatsCallback;
#else
    void*			m_pStats;
    void*			m_pUpdateStatsCallback;
#endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */

    CHXGenericCallback*		m_pHXPlayerCallback;
    CHXGenericCallback*		m_pHXPlayerInterruptCallback;
    CHXGenericCallback*		m_pSetupCallback;
#if defined(HELIX_FEATURE_AUTHENTICATION)
    CHXGenericCallback*		m_pAuthenticationCallback;
#else
    void*			m_pAuthenticationCallback;
#endif /* HELIX_FEATURE_AUTHENTICATION */
    IHXValues*			m_pAutheticationValues;

    ULONG32			m_ulStatsGranularity;

public:
    HXClientEngine*		m_pEngine;
    IHXPlugin2Handler*		m_pPlugin2Handler;
protected:
    IUnknown*			m_pClient;
    CHXAudioPlayer*		m_pAudioPlayer;
    
    CHXAdviseSinkControl*	m_pAdviseSink;
    CHXErrorSinkControl*  	m_pErrorSinkControl;
    
    IHXClientRequestSink*	m_pClientRequestSink;
    IHXPreferences*		m_pPreferences;
#if defined(HELIX_FEATURE_HYPER_NAVIGATE)
    PlayerHyperNavigate*	m_pHyperNavigate;
#else
    void*			m_pHyperNavigate;
#endif /* HELIX_FEATURE_HYPER_NAVIGATE */
#if defined(HELIX_FEATURE_PACKETHOOKMGR)
    IHXPacketHookManager*	m_pPacketHookManager;
#else
    void*			m_pPacketHookManager;
#endif /* HELIX_FEATURE_PACKETHOOKMGR */

#if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
    HXAdvancedGroupManager*     m_pGroupManager;
#else
    HXBasicGroupManager*	m_pGroupManager;
#endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */

    HXMasterTAC*		m_pMasterTAC;

    CHXSimpleList*		m_pRedirectList;

    IHXClientViewSource*	m_pClientViewSource;
    IHXClientViewRights*	m_pClientViewRights;
    IHXViewPortManager*	m_pViewPortManager;
#if defined(HELIX_FEATURE_MEDIAMARKER)
    CHXMediaMarkerManager*     m_pMediaMarkerManager;
#else
    void*			m_pMediaMarkerManager;
#endif /* #if defined(HELIX_FEATURE_MEDIAMARKER) */
#if defined(HELIX_FEATURE_EVENTMANAGER)
    CRendererEventManager*      m_pEventManager;
#else
    void*			m_pEventManager;
#endif /* #if defined(HELIX_FEATURE_EVENTMANAGER) */
    HXCookies*			m_pCookies;

#if defined(HELIX_FEATURE_NESTEDMETA)
    HXPersistentComponentManager*  m_pPersistentComponentManager;
#else
    void*			m_pPersistentComponentManager;
#endif /* HELIX_FEATURE_NESTEDMETA */
    HXPreferredTransportManager*   m_pPreferredTransportManager;
    IHXNetInterfaces*		    m_pNetInterfaces;

public:
			HXPlayer();
			~HXPlayer();

    /*
     * IUnknown methods
     */
    STDMETHOD(QueryInterface)	(THIS_
				REFIID riid,
				void** ppvObj);

    STDMETHOD_(ULONG32,AddRef)	(THIS);

    STDMETHOD_(ULONG32,Release)	(THIS);

    /*
     * IHXPlayer methods
     */

    /************************************************************************
     *	Method:
     *		IHXPlayer::GetClientEngine
     *	Purpose:
     *		Get the interface to the client engine object of which the player
     *		is a part of.
     *
     */
    STDMETHOD(GetClientEngine)	(THIS_
				    REF(IHXClientEngine*)	pEngine);

    /************************************************************************
     *	Method:
     *		IHXPlayer::OpenURL
     *	Purpose:
     *		Tell the player to begin playback of all its sources.
     *
     */
    STDMETHOD (OpenURL)		(THIS_
				    const char*	pURL);

    /************************************************************************
     *	Method:
     *		IHXPlayer::Begin
     *	Purpose:
     *		Tell the player to begin playback of all its sources.
     *
     */
    STDMETHOD (Begin)		(THIS);

    /************************************************************************
     *	Method:
     *		IHXPlayer::Stop
     *	Purpose:
     *		Tell the player to stop playback of all its sources.
     *
     */
    STDMETHOD (Stop)		(THIS);

    /************************************************************************
     *	Method:
     *		IHXPlayer::Pause
     *	Purpose:
     *		Tell the player to pause playback of all its sources.
     *
     */
    STDMETHOD (Pause)		(THIS);

    /************************************************************************
     *	Method:
     *		IHXPlayer::Seek
     *	Purpose:
     *		Tell the player to seek in the playback timeline of all its 
     *		sources.
     *
     */
    STDMETHOD (Seek)		(THIS_
				ULONG32			ulTime);

    /************************************************************************
     *	Method:
     *	    IHXPlayer::GetSourceCount
     *	Purpose:
     *	    Returns the current number of source instances supported by
     *	    this player instance.
     */
    STDMETHOD_(UINT16, GetSourceCount)(THIS);

    /************************************************************************
     *	Method:
     *	    IHXPlayer::GetSource
     *	Purpose:
     *	    Returns the Nth source instance supported by this player.
     */
    STDMETHOD(GetSource)	(THIS_
				UINT16		nIndex,
				REF(IUnknown*)	pUnknown);

    /************************************************************************
     *	Method:
     *	    IHXPlayer::SetClientContext
     *	Purpose:
     *	    Called by the client to install itself as the provider of client
     *	    services to the core. This is traditionally called by the top 
     *	    level client application.
     */
    STDMETHOD(SetClientContext)	(THIS_
				IUnknown* pUnknown);

    /************************************************************************
     *	Method:
     *	    IHXPlayer::GetClientContext
     *	Purpose:
     *	    Called by the get the client context for this player. This is 
     *	    traditionally to determine called by top level client application.
     */
    STDMETHOD(GetClientContext)	(THIS_
				REF(IUnknown*) pUnknown);

    /************************************************************************
     *	Method:
     *		IHXPlayer::IsDone
     *	Purpose:
     *		Ask the player if it is done with the current presentation
     *
     */
    STDMETHOD_ (BOOL,IsDone)	(THIS);

    /************************************************************************
     *	Method:
     *		IHXPlayer::IsLive
     *	Purpose:
     *		Ask the player whether it contains the live source
     *
     */
    STDMETHOD_ (BOOL,IsLive)	(THIS);

    /************************************************************************
     *	Method:
     *		IHXPlayer::GetCurrentPlayTime
     *	Purpose:
     *		Get the current time on the Player timeline
     *
     */
    STDMETHOD_ (ULONG32,GetCurrentPlayTime)	(THIS);

    /************************************************************************
     *	Method:
     *	    IHXPlayer::AddAdviseSink
     *	Purpose:
     *	    Call this method to add a client advise sink.
     *
     */
    STDMETHOD(AddAdviseSink)	(THIS_
				IHXClientAdviseSink*	pAdviseSink);

    /************************************************************************
     *	Method:
     *	    IHXPlayer::RemoveAdviseSink
     *	Purpose:
     *	    Call this method to remove a client advise sink.
     */
    STDMETHOD(RemoveAdviseSink)	(THIS_
				IHXClientAdviseSink*	pAdviseSink);

    /************************************************************************
     *	Method:
     *	    IHXPlayer2::SetMinimumPreroll
     *	Purpose:
     *	    Call this method to set the minimum preroll of this clip
     */
    STDMETHOD(SetMinimumPreroll) (THIS_
				UINT32	ulMinPreroll);

    /************************************************************************
     *	Method:
     *	    IHXPlayer2::GetMinimumPreroll
     *	Purpose:
     *	    Call this method to get the minimum preroll of this clip
     */
    STDMETHOD(GetMinimumPreroll) (THIS_
				REF(UINT32) ulMinPreroll);

    /************************************************************************
     *	Method:
     *	    IHXPlayer2::OpenRequest
     *	Purpose:
     *	    Call this method to open the IHXRequest
     */
    STDMETHOD(OpenRequest) (THIS_
			    IHXRequest* pRequest);
    
    /************************************************************************
     *	Method:
     *	    IID_IHXPlayer2::GetRequest
     *	Purpose:
     *	    Call this method to get the IHXRequest
     */
    STDMETHOD(GetRequest) (THIS_
			   REF(IHXRequest*) pRequest);

    /************************************************************************
     *	Method:
     *	    EventOccurred
     *	Purpose:
     *	    Clients call this to pass OS events to the player. HXxEvent
     *	    defines a cross-platform event.
     */
    void EventOccurred(HXxEvent* pEvent);

#ifdef _UNIX
    void CollectSelectInfo(INT32 *n, 
			   fd_set* readfds,
			   fd_set* writefds, 
			   fd_set* exceptfds,
			   struct timeval* tv);
    void ProcessSelect(INT32* n,
		       fd_set* readfds,
		       fd_set* writefds, 
		       fd_set* exceptfds,
		       struct timeval* tv);
#endif

    /************************************************************************
     *	Method:
     *		GetInst
     *	Purpose:
     *		TBD
     *
     */
    ULONG32	GetInst(void);

    /************************************************************************
     *	Method:
     *		UpdateStatistics
     *	Purpose:
     *		Update statistics periodically
     *
     */
    HX_RESULT	UpdateStatistics(void);

    /************************************************************************
     *	Method:
     *		ProcessIdle
     *	Purpose:
     *		Work-Horse for the player...
     *
     */
    HX_RESULT	ProcessIdle(void);

    /************************************************************************
     *  Method:
     *      IHXAudioPlayerResponse::OnTimeSync
     *  Purpose:
     *      Notification interface provided by users of the IHXAudioPlayer 
     *      interface. This method is called by the IHXAudioPlayer when 
     *      audio playback occurs.
     */
    STDMETHOD(OnTimeSync)       (THIS_
				ULONG32			/*IN*/ ulTimeEnd);


    /************************************************************************
     *	Method:
     *		HXPlayer::Init
     *	Purpose:
     *		Get the interface to the client engine object of which the player
     *		is a part of. It is not a part of IHXPlayer interface
     *
     */
    STDMETHOD(Init)		(THIS_
				 IHXClientEngine*	pEngine,
				 UINT32			unRegistryID,
				 CHXAudioPlayer*	pAudioPlayer);

    /************************************************************************
     *	Method:
     *		HXPlayer::ReportError
     *	Purpose:
     *		The source object reports of any fatal errors. 
     *
     */
    void	ReportError (HXSource* pSource, 
			HX_RESULT theErr, const char* pUserString = NULL);

    // IHXPendingStatus methods

    /************************************************************************
     *	Method:
     *	    IHXPendingStatus::GetStatus
     *	Purpose:
     *	    Called by the user to get the current pending status from an object
     */
    STDMETHOD(GetStatus)	(THIS_
				REF(UINT16) uStatusCode, 
				REF(IHXBuffer*) pStatusDesc, 
				REF(UINT16) ulPercentDone);

    /************************************************************************
     *	Method:
     *	    HXPlayer::SetStatsGranularity
     *	Purpose:
     *	    Called by the user to set how often the statistics registry needs 
     *	    to be updated in ms
     */
    STDMETHOD(SetStatsGranularity)	(THIS_
					ULONG32	ulGranularity);

    /************************************************************************
     *	Method:
     *	    IHXPlayerPresentation::ClosePresentation
     *	Purpose:
     *	    Call this method to close the player's current presentation.  This will free
     *	    all resources associated with the current presentation.
     */