hxplay.h

linux下的一款播放器

    STDMETHOD(ClosePresentation)    (THIS);

    /*
     * IHXErrorMessages methods
     */

    /************************************************************************
     *	Method:
     *	    IHXErrorMessages::Report
     *	Purpose:
     *	    Call this method to report an error, event, or status message.
     */
    STDMETHOD(Report)		(THIS_
				const UINT8	unSeverity,  
				HX_RESULT	ulHXCode,
				const ULONG32	ulUserCode,
				const char*	pUserString,
				const char*	pMoreInfoURL
				);

    /************************************************************************
     *	Method:
     *	    IHXErrorMessages::GetErrorText
     *	Purpose:
     *	    Call this method to get the text description of a RMA error code.
     *	Parameters:
     *	    HX_RESULT	ulHXCode
     *      A RMA error code.
     *  Return Value:
     *	    IHXBuffer* containing error text.
     */
    STDMETHOD_(IHXBuffer*, GetErrorText)	(THIS_
						HX_RESULT	ulHXCode
						);

    /*
     *	IHXRegistryID methods
     */

    /************************************************************************
     *	Method:
     *	    IHXRegistryID::GetID
     *	Purpose:
     *	    Get registry ID(hash_key) of the objects(player, source and stream)
     *
     */
    STDMETHOD(GetID)		(THIS_
				REF(UINT32)	/*OUT*/  ulRegistryID);

    STDMETHOD(HandleAuthenticationRequest) 
                                     (IHXAuthenticationManagerResponse*);
    STDMETHOD(HandleAuthenticationRequest2)
    				    (IHXAuthenticationManagerResponse*, IHXValues*);

    // IHXAuthenticationManagerResponse
    STDMETHOD(AuthenticationRequestDone)
    (
	HX_RESULT HX_RESULTStatus,
	const char* pcharUser,
	const char* pcharPassword
    );
    
    /*
     *  IHXGroupSink methods
     */
    /************************************************************************
    *  Method:
    *      IHXGroupSink::GroupAdded
    *  Purpose:
    *		Notification of a new group being added to the presentation.
    */
    STDMETHOD(GroupAdded)    (THIS_
			    UINT16 	    /*IN*/ uGroupIndex,
			    IHXGroup*	    /*IN*/ pGroup);

    /************************************************************************
    *  Method:
    *      IHXGroupSink::GroupRemoved
    *  Purpose:
    *		Notification of a group being removed from the presentation.
    */
    STDMETHOD(GroupRemoved)    (THIS_
				UINT16 	    /*IN*/ uGroupIndex,
				IHXGroup*  /*IN*/ pGroup);

    /************************************************************************
    *  Method:
    *      IHXGroupSink::AllGroupsRemoved
    *  Purpose:
    *		Notification that all groups have been removed from the 
    *		current presentation.
    */
    STDMETHOD(AllGroupsRemoved)  (THIS);

    /************************************************************************
    *  Method:
    *      IHXGroupSink::TrackAdded
    *  Purpose:
    *		Notification of a new track being added to a group.
    */
    STDMETHOD(TrackAdded)  (THIS_
			    UINT16 	    /*IN*/ uGroupIndex,
			    UINT16 	    /*IN*/ uTrackIndex,
			    IHXValues*	    /*IN*/ pTrack);

    /************************************************************************
    *  Method:
    *      IHXGroupSink::TrackAdded
    *  Purpose:
    *		Notification of a track being removed from a group.
    */
    STDMETHOD(TrackRemoved)    (THIS_
				UINT16 		/*IN*/ uGroupIndex,
				UINT16 		/*IN*/ uTrackIndex,
				IHXValues*	/*IN*/ pTrack);

    /************************************************************************
    *  Method:
    *      IHXGroupSink::TrackStarted
    *  Purpose:
    *		Notification of a track being started in a group.
    */
    STDMETHOD(TrackStarted)    (THIS_
				UINT16 		/*IN*/ uGroupIndex,
				UINT16 		/*IN*/ uTrackIndex,
				IHXValues*	/*IN*/ pTrack);

    /************************************************************************
    *  Method:
    *      IHXGroupSink::TrackStopped
    *  Purpose:
    *		Notification of a track being stopped in a group.
    */
    STDMETHOD(TrackStopped)    (THIS_
				UINT16 		/*IN*/ uGroupIndex,
				UINT16 		/*IN*/ uTrackIndex,
				IHXValues*	/*IN*/ pTrack);

   /************************************************************************
    *  Method:
    *      IHXGroupSink::CurrentGroupSet
    *  Purpose:
    *		This group is being currently played in the presentation.
    */
    STDMETHOD(CurrentGroupSet)	(THIS_
				UINT16 	    /*IN*/ uGroupIndex,
				IHXGroup*  /*IN*/ pGroup);
           
    /*
     * IHXLayoutSiteGroupManager methods
     */
    /************************************************************************
    *  Method:
    *      IHXLayoutSiteGroupManager::AddLayoutSiteGroup
    *  Purpose:
    *		Add this LSG to the presentation
    */
    STDMETHOD(AddLayoutSiteGroup)	(THIS_
					IUnknown*  /*IN*/ pLSG);

    /************************************************************************
    *  Method:
    *      IHXLayoutSiteGroupManager::RemoveLayoutSiteGroup
    *  Purpose:
    *		Remove this LSG from the presentation
    */
    STDMETHOD(RemoveLayoutSiteGroup)	(THIS_
					IUnknown*  /*IN*/ pLSG);

    /*
     * IHXRendererUpgrade methods
     */
    /************************************************************************
    *  Method:
    *      IHXRendererUpgrade::IsRendererAvailable
    *  Purpose:
    *	   Is a renderer with this mime type already loaded?
    */
    STDMETHOD_(BOOL,IsRendererAvailable)(THIS_
					const char* /*IN*/ pMimeType);

    /************************************************************************
    *  Method:
    *      IHXRendererUpgrade::ForceUpgrade
    *  Purpose:
    *	   Force an upgrade of all renderers in list
    */
    STDMETHOD(ForceUpgrade)		(THIS);

    /*
     * IHXInternalReset method
     */
    STDMETHOD(InternalReset) (THIS);

    /*
     *	IHXPlayerState methods
     */
    STDMETHOD_(BOOL, IsPlaying)    (THIS) {return m_bIsPlaying;}

    /************************************************************************
     *  IHXViewSourceCommand methods
     */
    STDMETHOD_(BOOL, CanViewSource)	(THIS_  
					IHXStreamSource* pStream);
    STDMETHOD(DoViewSource)		(THIS_
					IHXStreamSource* pStream);
    STDMETHOD(GetViewSourceURL)		(THIS_
					IHXStreamSource*	    pSource,
					IHXViewSourceURLResponse*  pResp);

    /*
     * IHXOverrideDefaultServices methods
     */

    /************************************************************************
     *  Method:
     *      IHXOverrideDefaultServices::OverrideServices
     *  Purpose:
     *      Override default services provided by the G2 system.
     * 
     */
    STDMETHOD(OverrideServices)         (THIS_
				IUnknown* pContext);

    /*
     * IHXPlayerNavigator methods
     */

    /************************************************************************
     *	Method:
     *	    IHXPlayerNavigator::AddChildPlayer
     *	Purpose:
     *	    Add child player to the current player
     */
    STDMETHOD(AddChildPlayer)	    (THIS_
				    IHXPlayer* pPlayer);

    /************************************************************************
     *	Method:
     *	    IHXPlayerNavigator::RemoveChildPlayer
     *	Purpose:
     *	    Remove child player from the current player
     */
    STDMETHOD(RemoveChildPlayer)    (THIS_
				    IHXPlayer* pPlayer);

    /************************************************************************
     *	Method:
     *	    IHXPlayerNavigator::GetNumChildPlayer
     *	Purpose:
     *	    Get number of the child players
     */
    STDMETHOD_(UINT16, GetNumChildPlayer)    (THIS);

    /************************************************************************
     *	Method:
     *	    IHXPlayerNavigator::GetChildPlayer
     *	Purpose:
     *	    Get Nth child player
     */
    STDMETHOD(GetChildPlayer)	    (THIS_
				    UINT16 uPlayerIndex,
				    REF(IHXPlayer*) pPlayer);

    /************************************************************************
     *	Method:
     *	    IHXPlayerNavigator::SetParentPlayer
     *	Purpose:
     *	    Set the parent player
     */
    STDMETHOD(SetParentPlayer)	    (THIS_
				    IHXPlayer* pPlayer);

    /************************************************************************
     *	Method:
     *	    IHXPlayerNavigator::RemoveParentPlayer
     *	Purpose:
     *	    Remove the parent player
     */
    STDMETHOD(RemoveParentPlayer)   (THIS_
				    IHXPlayer* pPlayer);

    /************************************************************************
     *	Method:
     *	    IHXPlayerNavigator::GetParentPlayer
     *	Purpose:
     *	    Get the parent player
     */
    STDMETHOD(GetParentPlayer)	    (THIS_
				    REF(IHXPlayer*) pPlayer);

    /* 
     * IHXRecordManager methods 
     */ 

    /************************************************************************ 
     *  Method: 
     *      IHXRecordManager::LoadRecordService 
     *  Purpose: 
     *      Called by TLC to supply the Core with record service. 
     */ 
    STDMETHOD(LoadRecordService) (THIS_ IHXRecordService* pRecordService); 

    /************************************************************************ 
     *  Method: 
     *      IHXRecordManager::GetRecordService 
     *  Purpose: 
     *      return current record service for the Player. 
     */ 
    STDMETHOD(GetRecordService) (THIS_ REF(IHXRecordService*) pRecordService); 

    /************************************************************************ 
     *  Method: 
     *      IHXRecordManager::UnloadRecordService 
     *  Purpose: 
     *      Called by TLC to ask the Core to stop using record service. 
     */ 
    STDMETHOD(UnloadRecordService) (THIS); 

    ////////////////////////////////////////////////////////////////////
    //
    // The following members are related to meta-file support.
    //
public:
    void		SetModal(BOOL bModal) {m_bSetModal = bModal;};
    HX_RESULT		SetSingleURLPresentation(const CHXURL* pURL);

    HX_RESULT		AddURL(SourceInfo*& pSourceInfo, BOOL bAltURL);

    void		GetActiveRequest(IHXRequest*& pRequest)
			{
			    pRequest = NULL;			    

			    if (m_pRequest)
			    {
#if defined(HELIX_FEATURE_NESTEDMETA)
				// we want to keep the original copy of IHXRequest in SMIL/RAM
				// so that individual source within will have a "clean" copy of 
				// IHXRequest to start with
				if (m_pPersistentComponentManager &&
				    m_pPersistentComponentManager->m_pRootPersistentComponent &&
				    !m_pPersistentComponentManager->m_pRootPersistentComponent->m_bToBeClosed)
				{
				    CHXRequest::CreateFromWithRequestHeaderOnly(m_pRequest, &pRequest);
				}
				else
#endif /* HELIX_FEATURE_NESTEDMETA */
				if (m_bActiveRequest)
				{
				    pRequest = m_pRequest;
				    pRequest->AddRef();				
				}
			    }
			};

    void		ResetActiveRequest() {m_bActiveRequest = FALSE;};

    void		SetGranularity(ULONG32 ulGranularity);
    ULONG32		GetGranularity(void) {return m_ulLowestGranularity;};

    HX_RESULT		SetGranularity(HXSource* pSource, UINT16 uStreamNumber, 
				       UINT32 ulGranularity);

    void                ClosePlayer(void);
    
    void		InternalPause();		

    HX_RESULT		EventReady(HXSource* pSource, CHXEvent* pEvent);

    void		ShutDown(void);

    void		RegisterSourcesDone(void);

    BOOL		IsInitialized(void) {return m_bInitialized;};

    BOOL		CanBeStarted(HXSource* pSource, SourceInfo* pThisSourceInfo, BOOL bPartOfNextGroup);
    void		EndOfSource(HXSource* pSource);

    BOOL		CanBeFastStarted(SourceInfo* pSourceInfo);
    void		SureStreamSourceRegistered(SourceInfo* pSourceInfo);
    void		SureStreamSourceUnRegistered(SourceInfo* pSourceInfo);

    ULONG32		GetInternalCurrentPlayTime(void)
			    { return m_ulCurrentPlayTime; };

    HX_RESULT		HandleRedirectRequest(UINT16 nGroup, UINT16 nTrack, char* pURL);
    BOOL		IsAtSourceMap(SourceInfo* pSourceInfo);

    HX_RESULT		RepeatTrackAdded(UINT16		/*IN*/ uGroupIndex,
					 UINT16		/*IN*/ uTrackIndex,
					 IHXValues*	/*IN*/ pTrack);

    /* Temporary function */
    void		SetInterrupt(BOOL bUseCoreThread) 
			    {m_bUseCoreThread = bUseCoreThread;};
    virtual HX_RESULT	SendPacket(CHXEvent* pEvent);
    CHXAudioPlayer*	GetAudioPlayer(void) {return m_pAudioPlayer;};
    INT32		GetCurrentGroupID(void) {return m_nCurrentGroup;};
    void                NotifyPlaybackEndToTLC() {m_bIsPresentationClosedToBeSent = TRUE;};
    HX_RESULT		CopyRegInfo(UINT32 ulFromRegID, UINT32 ulToRegID);

    BOOL                IsSitePresent(IHXSite* pSite);
    void		CheckIfRendererNeedFocus(IUnknown* pRenderer);

    static void         PlayerCallback(void *pParam);
    static void		SetupCallback(void *pParam);
#if defined(HELIX_FEATURE_AUTHENTICATION)
    static void	        AuthenticationCallback(void *pParam);
#endif
    
    friend		class SourceInfo;
    friend		class HXSource;
    friend		class HXNetSource;
    friend		class HXFileSource;
    friend		class HXPersistentComponent;
    friend		class HXPersistentComponentManager;

private:
    HX_BITFIELD		m_bForceStatsUpdate : 1;
    HX_BITFIELD		m_bActiveRequest : 1;
    HX_BITFIELD		m_bAddLayoutSiteGroupCalled : 1;
    HX_BITFIELD		m_bDoRedirect : 1;
    HX_BITFIELD		m_bFastStartCheckDone : 1;
    HX_BITFIELD		m_bFastStart : 1;

    TurboPlayOffReason	m_turboPlayOffReason;

    UINT32		m_ulActiveSureStreamSource;

    INT32		m_nCurrentGroup;
    INT32		m_nGroupCount;

    HX_RESULT		DoOpenGroup(UINT16 nGroupNumber);
    HX_RESULT		OpenTrack(IHXValues* pTrack, UINT16 uGroupID, UINT16 uTrackID);
    void		PlayNextGroup();

    BOOL		CheckTrackAndSourceOnTrackStarted(INT32 nGroup, INT32 nTrack, UINT32 sourceID);

    BOOL		GetViewSourceStream(REF(IHXStreamSource*) pStrmSource);