hxplay.h

linux下的一款播放器

    BOOL		AreAllPacketsSent();

    HX_RESULT		GetSourceInfo(UINT16 uGroupIndex, UINT16 uTrackIndex, SourceInfo*& pSourceInfo);
    HX_RESULT		UpdateTrack(UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pValues);
    HX_RESULT		RemoveTrack(UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pValues);
    HX_RESULT		AddPrefetchTrack(UINT16 uGroupIndex, UINT16 uPrefetchTrackIndex, IHXValues* pValues);
    HX_RESULT		UpdatePrefetchTrack(UINT16 uGroupIndex, UINT16 uPrefetchTrackIndex, IHXValues* pValues);
    HX_RESULT		RemovePrefetchTrack(UINT16 uGroupIndex, UINT16 uPrefetchTrackIndex, IHXValues* pValues);
    HX_RESULT		PrefetchTrackDone(UINT16 uGroupIndex, UINT16 uPrefetchTrackIndex, HX_RESULT status);

    HX_RESULT		BeginTrack(UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pValues);    
    HX_RESULT		PauseTrack(UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pValues);
    HX_RESULT		SeekTrack(UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pValues, UINT32 ulSeekTime);    
    HX_RESULT		StopTrack(UINT16 uGroupIndex, UINT16 uTrackIndex, IHXValues* pValues);    
    HX_RESULT		SetSoundLevel(UINT16 uGroupIndex, UINT16 uTrackIndex, UINT16 uSoundLevel, BOOL bReflushAudioDevice);    

    void                CheckSourceRegistration(void);
    void                GetTimingFromURL(CHXURL* pURL, UINT32& ulStart, UINT32& ulEnd, UINT32& ulDelay, UINT32& ulDuration);

#if defined(HELIX_FEATURE_RECORDCONTROL)
    BOOL                IsRecordServiceEnabled();
#endif

protected:
    CHXSimpleList*	m_pAltURLs;
    CHXURL*		m_pURL;
    IHXRequest*	m_pRequest;

    HX_RESULT		AdjustSeekOnRepeatedSource(SourceInfo*	pSourceInfo, 
						   UINT32	ulSeekTime);

    HX_RESULT 		DoNetworkOpen(SourceInfo*& pSourceInfo, BOOL bAltURL);
    HX_RESULT 		DoFileSystemOpen(SourceInfo*& pSourceInfo, BOOL bAltURL);

    HX_RESULT		CreateSourceInfo(SourceInfo*& pSourceInfo, BOOL bAltURL);
    HX_RESULT		PrepareSourceInfo(IHXValues* pTrack, SourceInfo*& pSourceInfo);
    HX_RESULT		DoURLOpen(CHXURL* pURL, char* pMimeType);
    HX_RESULT		DoAltURL(void);
    HX_RESULT		DoAltURLOpen(char* pURL, BOOL bDefault, SourceInfo* pMainSourceInfo);
    HX_RESULT		SpawnSourceIfNeeded(SourceInfo* pSourceInfo);
    HX_RESULT		SwitchSourceIfNeeded(void);

    HX_RESULT		DoRedirect(void);
    HX_RESULT		OpenRedirect(const char* pszURL);

    HX_RESULT		InitializeRenderers(void);

    HX_RESULT		LayoutRenderers(void);
    virtual HX_RESULT	ProcessIdleExt(void);

    void		CreateDefaultRendererWindow
			    (
				RendererInfo*		    pRInfo,
				IHXRenderer*		    pRend,
				IHXBuffer*		    pDisplayInfo,
				const char*		    pName
			    );
    void		CreateLayoutWindow
			    (
				IHXMetaLayout*			pLayout
			    );

    /************************************************************************
     *	Method:
     *		ExecuteCurrentEvents
     *	Purpose:
     *		Send any due packets to the renderers
     *
     */
    HX_RESULT	ProcessCurrentEvents(void);

    /************************************************************************
     *	Method:
     *		DeleteAllEvents
     *	Purpose:
     *		Remove all pending events due to seek/stop.
     *
     */
    HX_RESULT	DeleteAllEvents(void);
    HX_RESULT	SendPreSeekEvents(void);
    void	StopAllStreams(EndCode endCode = END_STOP);
    
    virtual HX_RESULT	SendPreSeekEventsExt(void);         
    virtual HX_RESULT	StopAllStreamsExt(EndCode endCode = END_STOP);
    
    virtual SourceInfo*	    NewSourceInfo(void);
    virtual HXFileSource*  NewFileSource(void);
    virtual HXNetSource*   NewNetSource(void);
    virtual HX_RESULT	    OpenTrackExt(void);

    void	CloseAllRenderers(INT32 nGroupSwitchTo);
    HX_RESULT	UnRegisterCurrentSources(void);

    HX_RESULT	SetupAllStreams(void);
    void	ResetPlayer(void);
    void	ResetGroup(void);
    void	SetMinimumPushdown(void);
    void	SchedulePlayer(void);
    HX_RESULT	CheckForAudioResume(void);

    HX_RESULT	InitializeNetworkDrivers(void);

    inline	void	UpdateCurrentPlayTime( ULONG32 ulCurrentPlayTime );
    
    HX_RESULT	ActualReport(
			    const UINT8	unSeverity,  
			    HX_RESULT	ulHXCode,
			    const ULONG32	ulUserCode,
			    const char*	pUserString,
			    const char*	pMoreInfoURL);

    IHXPendingStatus*	m_pMetaSrcStatus;

    // list of sources
    CHXMapPtrToPtr*	m_pSourceMap;
    CHXSimpleList*	m_pPendingTrackList;

    // current time on the timeline for this player..
    // this would either be updated by the audio services of any rendering object
    // happens to be an audio renderer and decides to use our audio services...
    // ELSE it will be updated by a timer object... 
    ULONG32		m_ulCurrentPlayTime;	
    
#if defined(_MACINTOSH) || defined(_MAC_UNIX)
    // this tracks the current timeline for this player, with the caveat
    // that it's only updated when the current play time is updated at
    // system time. This is useful for deciding whether to allocated "extra"
    // time to the player or giving it back to the system -- a pretty
    // complicated issue on MacOS 8.
    ULONG32		m_ulCurrentSystemPlayTime;
#endif

    
    // Length of all sources!
    ULONG32		m_ulPresentationDuration;

    // used to inform renderers the pre and post seek info..
    ULONG32		m_ulTimeBeforeSeek;
    ULONG32		m_ulTimeAfterSeek;


    BufferingReason	m_BufferingReason;

    CHXEventList	m_EventList;	// contains packets for all streams

    IHXScheduler*	m_pScheduler;

    /* m_uNumSourcesActive gets decremented when we have sucked out all the packets
     * from the source 
     */
    UINT16		m_uNumSourcesActive : 16;

    /* m_uNumCurrentSourceNotDone gets decremented when a given source has received
     * all the packets from the server
     */
    UINT16		m_uNumCurrentSourceNotDone : 16;

    HX_BITFIELD		m_bSourceMapUpdated : 1;
    HX_BITFIELD		m_bInitialized : 1;
       
    // m_bIsDone: single presentation/individual group in a SMIL file
    // m_bIsPresentationDone: single/SMIL presentation
    HX_BITFIELD		m_bIsDone : 1;
    HX_BITFIELD		m_bIsPresentationDone : 1;
    HX_BITFIELD		m_bInStop : 1;
    HX_BITFIELD		m_bIsPresentationClosedToBeSent : 1;
    HX_BITFIELD		m_bCloseAllRenderersPending : 1;

    HX_BITFIELD		m_bUseCoreThread : 1;
    HX_BITFIELD		m_bCoreLocked : 1;
    HX_BITFIELD		m_bPaused : 1;
    HX_BITFIELD		m_bBeginPending : 1;

    HX_BITFIELD		m_bIsFirstBeginPending : 1;

    HX_BITFIELD		m_bIsFirstBegin : 1;

    HX_BITFIELD		m_bUserHasCalledBegin : 1;

    HX_BITFIELD		m_bTimelineToBeResumed : 1;
    HX_BITFIELD		m_bIsPlaying : 1;

    HX_BITFIELD		m_bNetInitialized : 1;
    HX_BITFIELD		m_bPrefTransportInitialized : 1;

    HX_BITFIELD		m_bSetupLayoutSiteGroup : 1;
    
    HX_BITFIELD		m_bTimeSyncLocked : 1;

    HX_BITFIELD		m_bIsLive : 1;
    HX_BITFIELD		m_bLiveSeekToBeDone : 1;

    HX_BITFIELD		m_bProcessEventsLocked : 1;
    HX_BITFIELD		m_bDidWeDeleteAllEvents : 1;

    ULONG32		m_ulLowestGranularity;
    UINT32		m_ulElapsedPauseTime;
    UINT32		m_ulLiveSeekTime;
    UINT32		m_ulTimeOfPause;
    UINT32		m_ulMinimumAudioPreroll;
    UINT32		m_ulMinimumTotalPreroll;
    
    friend class HXPlayerCallback;

//#if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
    friend class UpdateStatsCallback;
//#endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */

    /* Used for multiple kive stream synchrnoization*/
    UINT32		m_ulFirstTimeSync;

    UINT32		m_ulFSBufferingEndTime;
    UINT16		m_uNumSourceToBeInitializedBeforeBegin : 16;

    HX_BITFIELD		m_bFastStartInProgress : 1;
    HX_BITFIELD		m_bIsFirstTimeSync : 1;
    HX_BITFIELD		m_bPlayerWithoutSources : 1;
    HX_BITFIELD		m_bInternalPauseResume : 1;
    HX_BITFIELD		m_bInternalReset : 1;
    HX_BITFIELD		m_bCurrentPresentationClosed : 1;
    HX_BITFIELD		m_bContactingDone : 1;
    HX_BITFIELD		m_bFSBufferingEnd : 1;
    HX_BITFIELD		m_bAllLocalSources : 1;
    HX_BITFIELD		m_b100BufferingToBeSent : 1;
    HX_BITFIELD		m_bSetupToBeDone : 1;
    HX_BITFIELD		m_bPostSetupToBeDone : 1;
    HX_BITFIELD		m_bInternalReportError : 1;
    HX_BITFIELD		m_bPartOfNextGroup : 1;   
    HX_BITFIELD		m_bLastGroup : 1;
    HX_BITFIELD		m_bNextGroupStarted : 1;
    HX_BITFIELD		m_bBeginChangeLayoutTobeCalled : 1;
    HX_BITFIELD		m_bPendingAudioPause : 1;
    HX_BITFIELD		m_bPlayStateNotified : 1;
    HX_BITFIELD		m_bResumeOnlyAtSystemTime : 1;
    HX_BITFIELD		m_bSetModal : 1;

#if defined(HELIX_FEATURE_PREFETCH)
    PrefetchManager*	m_pPrefetchManager;
#else
    void*		m_pPrefetchManager;
#endif /* HELIX_FEATURE_PREFETCH */

#ifdef _WIN32
    BOOL		m_bScreenSaverActive; 
#endif

#if defined(HELIX_FEATURE_NEXTGROUPMGR)
    NextGroupManager*	m_pNextGroupManager;
#else
    void*		m_pNextGroupManager;
#endif /* HELIX_FEATURE_NEXTGROUPMGR*/

    IHXGroup*		m_pCurrentGroup;

    IHXPlayer*		m_pParentPlayer;
    CHXSimpleList*	m_pChildPlayerList;

#if defined(HELIX_FEATURE_ASM)
    IHXBandwidthManager* m_pBandwidthMgr;
    /* Only used for load testing */
    IHXBandwidthManager* m_pASM;
#endif /* HELIX_FEATURE_ASM */

    CHXSimpleList	m_ToBeginRendererList;	
    void		EnterToBeginList(RendererInfo* pRendInfo);
    void		EmptyBeginList(void) {m_ToBeginRendererList.RemoveAll();};
    HX_RESULT		CheckBeginList(void);
    void		RemoveFromPendingList(RendererInfo* pRendInfo);

    void		CheckToStartNextGroup(void);
    void		AdjustPresentationTime(void);
    void		SetPresentationTime(UINT32 ulPresentationTime);

    void		UpdateSourceActive(void);
    HX_RESULT		UpdateSourceInfo(SourceInfo* pSourceInfo, 
					 UINT32 ulParentRegId,
					 UINT16 ulTrackIndex);
    HX_RESULT		UpdatePersistentSrcInfo(SourceInfo* pSourceInfo, 
                                                UINT32 ulParentRegId,
                                                UINT16 ulTrackIndex);

    /*
     * The following members are related to the new layout support.
     */
#if defined(HELIX_FEATURE_VIDEO)
    CHXSiteManager*	m_pSiteManager;
    IHXSiteSupplier*	m_pSiteSupplier;
#else
    void*		m_pSiteManager;
    void*		m_pSiteSupplier;
#endif /* HELIX_FEATURE_VIDEO */

    CHXSimpleList	m_SiteRequestIDList;
    
    void		SetupRendererSite(IUnknown* pRenderer, IHXValues* pProps, BOOL bIsPersistent);
    void		SetupLayoutSiteGroup(IUnknown* pLSG, BOOL bIsPersistent);
    STDMETHODIMP	SetupLayout(BOOL bIsPersistent);
    STDMETHODIMP	CleanupLayout(void);

    HX_RESULT		StartDownload(void);
    HX_RESULT		PauseDownload(void);
    void		UnregisterNonActiveSources();
    BOOL		AreAllSourcesSeekable(void);
    void		ResetError(void);
    void		ResetRedirectList(void);
    void		SetLastError(HX_RESULT theErr);

    void		Close();
    void		AbortPlayer(void);
    void		StopPlayer(EndCode endCode = END_STOP);
    HX_RESULT		PausePlayer(BOOL bNotifyTLC = TRUE);
    HX_RESULT		SeekPlayer(ULONG32 ulTime);
    HX_RESULT		BeginPlayer(void);

    HX_RESULT		SetupAudioPlayer(void);
    virtual HX_RESULT	PrepareAudioPlayer(void);

//#if defined(HELIX_FEATURE_AUTHENTICATION)
    void		ProcessPendingAuthentication();
    void		ClearPendingAuthenticationRequests();
//#endif /* HELIX_FEATURE_AUTHENTICATION */

    void		SendPostSeekIfNecessary(RendererInfo* pRendererInfo);

    BOOL		ScheduleOnTimeSync(void);
    BOOL		DurationTimeSyncAllSent(SourceInfo* pSourceInfo);
    virtual void	DisableScreenSaver();
    void                RemovePendingCallback(CHXGenericCallback* pCB);

#if defined(HELIX_FEATURE_AUTOUPGRADE)
    IHXUpgradeCollection* m_pUpgradeCollection;
#else
    void* m_pUpgradeCollection;
#endif /* HELIX_FEATURE_AUTOUPGRADE */

    friend class NextGroupManager;

//#if defined(HELIX_FEATURE_PREFETCH)
    friend class PrefetchManager;
//#endif /* HELIX_FEATURE_PREFETCH */
    
    // used to notify of changes to the precache group
#if defined(HELIX_FEATURE_ADVANCEDGROUPMGR)
    friend class HXAdvancedGroup;    
    friend class HXAdvancedGroupManager;    
#endif /* HELIX_FEATURE_ADVANCEDGROUPMGR */

#if defined(HELIX_FEATURE_BASICGROUPMGR)
    friend class HXBasicGroup;
    friend class HXBasicGroupManager;
#endif /* HELIX_FEATURE_BASICGROUPMGR */

    HX_RESULT NextGroupSet(UINT16 uGroupIndex);

//#if defined(HELIX_FEATURE_AUTHENTICATION)
#ifndef _WIN16
    // Store pending requests
    friend class _CHXAuthenticationRequests;
    _CHXAuthenticationRequests m_AuthenticationRequestsPending;
#endif /* _WIN16 */
//#endif /* HELIX_FEATURE_AUTHENTICATION */

    HXMutex*		m_pCoreMutex;

    /*
     * -- LIVE SYNC SUPPORT --
     *
     * The following is related to shared wall clock support
     * for syncronizing several live sources. See srcinfo.cpp
     * for more informantion.
     */
private:
    CHXMapStringToOb*	m_pSharedWallClocks;
    friend class SharedWallClock;

    IHXRecordService*	m_pRecordService;
    BOOL                m_bRecordServiceEnabled;

public:
    BOOL FindSharedWallClocks(const char* pClockName, void*& ppValue)
	    {
		return m_pSharedWallClocks->Lookup(pClockName,ppValue);
	    };
};

#if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
class UpdateStatsCallback : public IHXCallback
{
public:
    HXPlayer*		m_pPlayer;
    CallbackHandle	m_PendingHandle;
    BOOL		m_bIsCallbackPending;

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

    STDMETHOD_(ULONG32,AddRef)	(THIS);

    STDMETHOD_(ULONG32,Release)	(THIS);

    /*
     *	IHXCallback methods
     */
    STDMETHOD(Func)		(THIS);

protected:
			~UpdateStatsCallback();

    LONG32		m_lRefCount;
};
#endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */

#if defined (_WIN32) || defined (_MACINTOSH) || defined(THREADS_SUPPORTED)
class HXPlayerCallback : public CHXGenericCallback
                       , public IHXInterruptSafe
{
public:    
    BOOL m_bInterrupSafe;

    HXPlayerCallback(void* pParam, fGenericCBFunc pFunc);
    
    STDMETHOD_(ULONG32,AddRef)	(THIS) {return CHXGenericCallback::AddRef();}
    STDMETHOD_(ULONG32,Release)	(THIS) {return CHXGenericCallback::Release();}
    STDMETHOD(QueryInterface) (THIS_ REFIID riid, void** ppvObj);

    STDMETHOD_(BOOL,IsInterruptSafe) (THIS);

protected:
    ~HXPlayerCallback() {};
};
#endif //(_WIN32) || defined (_MACINTOSH) || defined(THREADS_SUPPORTED)

#endif //_HXPLAYER_