srcinfo.h
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:13k
源码类别:

Symbian

开发平台:

C/C++

  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 ***** */ 
  35. #ifndef _SOURCEINFO_
  36. #define _SOURCEINFO_
  37. #include "hxcbobj.h"
  38. // forward decl.
  39. _INTERFACE IHXPlayer;      
  40. _INTERFACE IHXPlayerProps;
  41. _INTERFACE IHXRenderer;
  42. _INTERFACE IHXScheduler;
  43. _INTERFACE IHXPendingStatus;
  44. _INTERFACE IHXMetaTrack;
  45. _INTERFACE IHXMetaLayout;
  46. class HXSource;
  47. class HXStream;
  48. class CTimeSyncCallback;
  49. class CSignatureChecker;
  50. struct STREAM_INFO;
  51. typedef ULONG32 BufferingReason;
  52. struct RepeatInfo;
  53. struct RendererInfo;
  54. class  SourceInfo;
  55. class  HXPlayer;
  56. class  HXMutex;
  57. struct IHXPluginSearchEnumerator;
  58. struct timeSyncParamStruct
  59. {
  60.     SourceInfo* pSourceInfo;
  61.     RendererInfo* pRenderInfo;
  62. };
  63. struct RepeatInfo
  64. {
  65.     UINT16  uTrackID;
  66.     UINT32  ulStart;
  67.     UINT32  ulEnd;
  68.     UINT32  ulDelay;
  69.     UINT32  ulDuration;
  70. };
  71. // stores header info for each renderer
  72. struct RendererInfo
  73. {
  74.     RendererInfo()
  75.     {
  76. m_pRenderer     = NULL;
  77. m_pStreamInfo     = NULL;
  78. m_ulLatestEventTime     = 0;
  79. m_ulGranularity     = 0;
  80. m_ulLastSyncTime     = 0;
  81. m_ulNextDueSyncTime     = 0;
  82. m_ulDuration     = 0;
  83. m_pTimeSyncCallback     = 0;
  84. m_pTimeSyncCBTime     = new Timeval;
  85. m_bIsFirstCallback     = TRUE;
  86. m_BufferingReason     = BUFFERING_START_UP;
  87. m_ulNumberOfPacketsQueued   = 0;
  88. m_ulStreamStartTime     = 0;
  89. m_ulTimeDiff     = 0;
  90. m_bTimeDiffPositive     = TRUE;
  91. m_bIsFirstPacket     = TRUE;
  92. m_bIsFirstTimeSync     = TRUE;
  93. m_bIsPersistent     = FALSE;
  94. m_pStream     = NULL;
  95. m_pRendererEnumerator     = NULL;
  96. m_bInitialBeginToBeSent     = TRUE;
  97.      m_bInterruptSafe     = FALSE;
  98. m_bDurationTimeSyncSent     = FALSE;
  99. m_bOnEndOfPacketSent     = FALSE;
  100.     };
  101.     ~RendererInfo()
  102.     {
  103. if (m_pTimeSyncCBTime)
  104. {
  105.     delete m_pTimeSyncCBTime;
  106.     m_pTimeSyncCBTime = 0;
  107. }
  108.     };
  109.     IHXRenderer* m_pRenderer;
  110.     STREAM_INFO* m_pStreamInfo;
  111.     ULONG32 m_ulLatestEventTime;
  112.     ULONG32 m_ulGranularity;
  113.     ULONG32 m_ulLastSyncTime;
  114.     ULONG32 m_ulNextDueSyncTime;
  115.     ULONG32 m_ulDuration;
  116.     CTimeSyncCallback*  m_pTimeSyncCallback;
  117.     Timeval* m_pTimeSyncCBTime;
  118.     BufferingReason m_BufferingReason;
  119.     UINT32 m_ulStreamStartTime;
  120.     UINT32 m_ulTimeDiff;
  121.     HXStream* m_pStream;
  122.     IHXPluginSearchEnumerator* m_pRendererEnumerator;
  123.     UINT16 m_ulNumberOfPacketsQueued : 16;
  124.     HX_BITFIELD m_bIsCallbackPending : 1;
  125.     HX_BITFIELD m_bIsFirstCallback : 1;
  126.     HX_BITFIELD m_bTimeDiffPositive : 1;
  127.     HX_BITFIELD m_bIsFirstPacket : 1;
  128.     HX_BITFIELD m_bIsFirstTimeSync : 1;
  129.     HX_BITFIELD m_bIsPersistent : 1;
  130.     HX_BITFIELD m_bInitialBeginToBeSent : 1;
  131.     HX_BITFIELD m_bInterruptSafe : 1;
  132.     HX_BITFIELD m_bDurationTimeSyncSent : 1;
  133.     HX_BITFIELD m_bOnEndOfPacketSent : 1;
  134. };
  135. /*
  136.  * -- LIVE SYNC SUPPORT --
  137.  *
  138.  * The SharedWallClock class is used for supporting syncing of
  139.  * multiple live sources. See other LIVE SYNC SUPPORT comments 
  140.  * in the source code for more details.
  141.  */
  142. class SourceInfo;
  143. class SharedWallClock
  144. {
  145. protected:
  146.     CHXString m_strName;
  147.     UINT32 m_ulStartTime;
  148.     CHXSimpleList m_UserList;
  149.     /* A wall clock is only associated with one player */
  150.     HXPlayer* m_pPlayer; 
  151. public:
  152.     SharedWallClock(const char* pName, UINT32 ulStartTime,HXPlayer* pPlayer);
  153.     UINT32 ResetStartTime(UINT32 ulStartTime);
  154.     UINT32 GetStartTime() { return m_ulStartTime; };
  155.     void AddUser(SourceInfo* pSourceInfo);
  156.     void RemoveUser(SourceInfo* pSourceInfo);
  157. };
  158. class SourceInfo
  159. {
  160. public:
  161. SourceInfo(HXPlayer* pPlayer);
  162. ~SourceInfo();
  163.     HX_RESULT Begin(void);
  164.     HX_RESULT Pause(void);
  165.     HX_RESULT Seek(UINT32 ulSeekTo);
  166.     void Stop(EndCode endCode = END_STOP);
  167.     void Remove(void);
  168.     void Reset(void);
  169.     virtual void DoCleanup(EndCode endCode = END_STOP);
  170.     void RenderersCleanup(void);
  171.     virtual void RenderersCleanupExt(RendererInfo* pRendInfo);
  172.     virtual RendererInfo* NewRendererInfo();
  173.     HX_RESULT BeginTrack(void);    
  174.     HX_RESULT PauseTrack(void);
  175.     HX_RESULT SeekTrack(UINT32 ulSeekTime);    
  176.     HX_RESULT StopTrack(void);    
  177.     HX_RESULT SetSoundLevel(UINT16 uSoundLevel, BOOL bReflushAudioDevice);
  178.     HX_RESULT ProcessIdle(BOOL bIsFirst,
  179.     ULONG32& ulNumStreamsToBeFilled,
  180.     BOOL& bIsBuffering,
  181.     UINT16& uLowestBuffering,
  182.     BOOL bPersistent = FALSE);
  183.     HX_RESULT Register(void);
  184.     HX_RESULT UnRegister(void);
  185.     void CheckIfDone(void);
  186.     void SetupRendererSites(BOOL bIsPersistent);
  187.     HX_RESULT InitializeAndSetupRendererSites();
  188.     HX_RESULT InitializeRenderers(BOOL& bSourceInitialized);
  189.     virtual HX_RESULT InitializeRenderersExt(BOOL& bSourceInitialized);
  190.     HX_RESULT SetupStreams(void);
  191.     HX_RESULT SetupRenderer(RendererInfo*& pRendInfo, 
  192.       IHXRenderer*& pRenderer,
  193.       STREAM_INFO*& pStreamInfo, 
  194.       HXStream*& pStream);
  195.     HX_RESULT CloseRenderers(void);
  196.     HX_RESULT OnTimeSync(ULONG32 ulCurrentTime);
  197.     HX_RESULT OnTimeSync(RendererInfo* pRendInfo, 
  198.    BOOL bUseCurrentTime = FALSE);
  199.     void ChangeAccelerationStatus(BOOL bMayBeAccelerated,
  200.  BOOL bUseAccelerationFactor = FALSE,
  201.  UINT32 ulAccelerationFactor = 0);
  202.     BOOL IsInitialized()     {return m_bInitialized;};
  203.     BOOL AreStreamsSetup()     {return m_bAreStreamsSetup;};
  204.     
  205.     BOOL IsRegistered()     {return m_bIsRegisterSourceDone;}; 
  206.     BOOL IsActive()     {return m_bActive;}; 
  207.     void Resumed();
  208.     void UpdateDuration(UINT32 ulDuration);
  209.     void UpdateDelay(UINT32 ulDelay);
  210.     BOOL ToBeInitialized() {return m_bTobeInitializedBeforeBegin;};
  211.     void ReInitializeStats();
  212.     BOOL IsRebufferDone(void);
  213.     HX_RESULT HandleRedirectRequest(char* pURL);
  214.     void ScheduleProcessCallback();
  215.     void SetLiveSyncStartTime(HXSource* pSource, 
  216.      RendererInfo* pTmpRendInfo, 
  217.      UINT32 ulLowestTime);
  218.     BOOL AllOtherStreamsHaveEnded(STREAM_INFO* pThisStreamInfo);    
  219.     CHXSimpleList* GetRepeatList() {return m_bLeadingSource?m_pRepeatList:m_pPeerSourceInfo->m_pRepeatList; };
  220.     HX_RESULT AppendRepeatRequest(UINT16 uTrackID, IHXValues* pTrack);
  221.     BOOL IsAdjustSeekNeeded(UINT32 ulSeekTime);
  222.     SourceInfo* DoAdjustSeek(UINT32 ulSeekTime);
  223.     UINT32 GetActiveDuration();
  224.     BOOL KeepSourceActive(void);    
  225.     BOOL IsDone() { return (BOOL)m_bDone;};
  226.     friend class HXPlayer;
  227.     friend class NextGroupManager;
  228.     friend class PrefetchManager;
  229.     friend class CTimeSyncCallback;
  230.     friend class ProcessCallback;
  231.     friend class HXPersistentComponent;
  232.     friend class HXPersistentComponentManager;
  233.     friend class HXSource;
  234.     friend class HXFileSource;
  235.     friend class HXNetSource;
  236.     // XXX HP
  237.     LISTPOSITION m_curPosition;
  238.     CHXSimpleList* m_pRepeatList;    
  239.     SourceInfo* m_pPeerSourceInfo;
  240.     HXSource* m_pSource;
  241.     HX_BITFIELD m_bLeadingSource : 1;
  242.     HX_BITFIELD m_bSeekPending : 1;
  243.     HX_BITFIELD m_bIndefiniteDuration : 1;
  244.     HX_BITFIELD m_bRepeatPending : 1;
  245.     HX_BITFIELD m_bRepeatIndefinite : 1;    
  246.     HX_BITFIELD m_bSeekToLastFrame : 1;
  247.     UINT16 m_uGroupID;
  248.     UINT16 m_uTrackID;
  249.     UINT32 m_ulPersistentComponentID;
  250.     UINT32 m_ulPersistentComponentSelfID;
  251.     UINT32 m_ulMaxDuration;    
  252.     UINT32 m_ulSeekTime;
  253.     UINT32 m_ulRepeatInterval;
  254.     UINT32 m_ulRepeatDelayTimeOffset;
  255.     CHXMapLongToObj* m_pRendererMap;     // list of renderers for this source...
  256. protected:
  257.     HXPlayer* m_pPlayer;
  258.     IHXPendingStatus* m_pStatus;
  259.     IHXRendererAdviseSink* m_pRendererAdviseSink;
  260.     HX_BITFIELD m_bDone : 1;     // source end...all streams are done..
  261.     HX_BITFIELD m_bStopped : 1;     // track stopped
  262.     HX_BITFIELD m_bInitialized : 1; // all streams of source have been 
  263.     // associated with renderers?
  264.     HX_BITFIELD m_bAllPacketsReceived : 1;
  265.     HX_BITFIELD m_bActive : 1;
  266.     HX_BITFIELD m_bIsPersistentSource : 1;
  267.     HX_BITFIELD m_bIsRegisterSourceDone : 1;
  268.     HX_BITFIELD m_bAltURL : 1;
  269.     HX_BITFIELD m_bToBeResumed : 1;
  270.     HX_BITFIELD m_bAreStreamsSetup : 1;
  271.     HX_BITFIELD m_bTrackStartedToBeSent : 1;
  272.     HX_BITFIELD m_bTrackStoppedToBeSent : 1;
  273.     HX_BITFIELD m_bPrefetch : 1;
  274.     HX_BITFIELD m_bLoadPluginAttempted : 1;
  275.     HX_BITFIELD m_bTobeInitializedBeforeBegin : 1;
  276.     HX_BITFIELD m_bLocked : 1;
  277.     HX_BITFIELD m_bIsTrackDurationSet : 1;
  278.     HX_BITFIELD m_bDurationTimeSyncScheduled : 1;
  279.     HX_BITFIELD m_bAudioDeviceReflushHint : 1;
  280.     HX_RESULT m_lastErrorFromMainURL;
  281.     HX_RESULT           m_lastError;
  282.     CHXString m_lastErrorStringFromMainURL;
  283.     CHXString m_id;
  284.     CHXSimpleList* m_pCurrentScheduleList;
  285.     /*
  286.            repeat0            repeat1             repeat2            repeat3
  287.      |------------------|------------------|------------------|------------------|
  288.      ^          ^       ^                                                        ^
  289.      |----------|       |                                                        |
  290.    (sourceduration)     |                                                        |
  291.      ^                  |                                                        |
  292.      |------------------|                                                        |
  293.        (trackduration)                                                           |
  294.      ^                                                                           |
  295.      |---------------------------------------------------------------------------|
  296.                                 (totaltrackduration)
  297.      */
  298.     UINT32 m_ulSourceDuration; // encoded duration
  299.     UINT32 m_ulTrackDuration; // customized duration(per repeat)
  300.     UINT32 m_ulTotalTrackDuration; // customized total duration(total repeats)
  301.     UINT32 m_ulPausedStartTime;
  302.     UINT16* m_pDependNode;
  303.     UINT16 m_uNumDependencies;
  304.     HXMutex* m_pMutex;
  305.     CHXGenericCallback*m_pProcessCallback;
  306.     INT64 m_llLatestPacketTime;
  307.     PrefetchType m_prefetchType;
  308.     UINT32 m_ulPrefetchValue;
  309.     UINT16 m_uSoundLevel;
  310.     FillType m_fillType;
  311. /*
  312.  * -- LIVE SYNC SUPPORT --
  313.  *
  314.  * The SharedWallClock class is used for supporting syncing of
  315.  * multiple live sources. See other LIVE SYNC SUPPORT comments 
  316.  * in the source code for more details.
  317.  */
  318. private:
  319.     UINT32 CalculateLiveStartTime(IHXPacket* pFirstPacket);
  320.     void DoneWithWallClock();
  321.     UINT32 m_ulStreamStartTime;
  322.     CHXString m_strWallClockName;
  323.     SharedWallClock* m_pWallClock;
  324. public:
  325.     void ResetStartTime(UINT32 ulStartTime);
  326.     static void         TimeSyncCallback(void* pParam);
  327.     static void         ProcessCallback(void* pParam);
  328. };
  329. class CTimeSyncCallback : public CHXGenericCallback
  330. {
  331. public:
  332.     CTimeSyncCallback(void* pParam, fGenericCBFunc pFunc)
  333.      : CHXGenericCallback(pParam, pFunc)
  334.     {
  335.         m_pParam = (void*)new struct timeSyncParamStruct;
  336.         *((struct timeSyncParamStruct*)m_pParam) = *((struct timeSyncParamStruct*)pParam);
  337.     }
  338.     virtual ~CTimeSyncCallback()
  339.     {
  340.         if (m_pParam)
  341.         {
  342.             delete (timeSyncParamStruct*)m_pParam;
  343.         }
  344.     }
  345. };
  346. #endif /*_SOURCEINFO_*/