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

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 _HX_BSOURCE_
  36. #define _HX_BSOURCE_
  37. #include "hxresult.h"
  38. #include "hxtypes.h"
  39. #include "hxurl.h"
  40. #include "hxcomm.h" // IHXRegistryID
  41. #include "plprefk.h"
  42. #include "hxmap.h"
  43. #include "hxfiles.h"
  44. #include "hxasm.h"
  45. #include "hxmon.h"
  46. #include "hxhyper.h"
  47. #include "hxclreg.h"
  48. #include "hxpends.h"
  49. #include "chxelst.h"
  50. #include "statsmgr.h"
  51. #include "statinfo.h"
  52. #include "strminfo.h"
  53. #include "buffmgr.h"
  54. #include "hxausvc.h"
  55. #include "hxaudply.h"
  56. #include "hxplugn.h"
  57. #include "smiltype.h"
  58. #include "recordctl.h"
  59. #include "hxcore.h"
  60. // need to go in hxresult.h
  61. #define HX_INVALID_HEADER HXR_INVALID_PARAMETER
  62. #define NUM_MILLISECS_IN_A_SEC ((ULONG32) 1000)
  63. #define HX_LATE_PACKET HXR_FAILED
  64. #define HX_DUPLICATE_PACKET (HXR_FAILED + 1)
  65. ///////////////////////////////////////////////////////////////
  66. // PERFECTPLAY_FUDGE_FACTOR
  67. //
  68. // Percentage of average download to consider for calculations. 
  69. // 100 = 100% and assumes that the average download time is 
  70. // correct. Larger numbers (i.e. 110) would handle the case of 
  71. // the average being lucky as if all future blocks come in at 
  72. // slower rate.
  73. #define PERFECTPLAY_FUDGE_FACTOR (110)
  74. ///////////////////////////////////////////////////////////////
  75. // PERFECTPLAY_FUDGE_FACTOR_BASE
  76. //
  77. // Base unit of measure for percentage of average download to 
  78. // consider for calculations.
  79. #define PERFECTPLAY_FUDGE_FACTOR_BASE (100)
  80. ///////////////////////////////////////////////////////////////
  81. // PERFECTPLAY_MIN_BUFFERS
  82. //
  83. // Due to the behavior of pn_net's de-interleaving support
  84. // we must make sure that we have at least 3 superblocks of
  85. // buffers before we can start playback in perfect play mode.
  86. // I have tried smaller amounts, in particular I thought 
  87. // MIN_LEAD_BLOCKS would be a logical number, but this was not
  88. // conservative enough and the playback would stop prematurely
  89. // even though there was data available.
  90. #define PERFECTPLAY_MIN_BUFFERS (mInterleaveFactor * 3)
  91. ///////////////////////////////////////////////////////////////
  92. // PERFECTPLAY_TICKS_PER_SECOND
  93. //
  94. // Since the different OS's return different meanings for "ticks"
  95. // we will use this as the ratio of ticks to seconds.
  96. #ifdef __MWERKS__
  97. #define PERFECTPLAY_TICKS_PER_SECOND 60
  98. #else
  99. #define PERFECTPLAY_TICKS_PER_SECOND 100
  100. #endif
  101. ///////////////////////////////////////////////////////////////
  102. // PERFECTPLAY_MIN_TIME
  103. //
  104. // Also due to the behavior of pn_net's de-interleaving support
  105. // we can't play for less than about 3 superblocks of audio, so
  106. // this define will represent this in seconds.
  107. // This is a reasonable minimun perfect play time
  108. #define PERFECTPLAY_MIN_TIME 10
  109. #define MINIMUM_PLAY_TIME   10000 /* in ms.*/
  110. /* Approx Time to be taken for network buffering */
  111. #define NETWORK_FUDGE_FACTOR 2000
  112. #define MIN_BUFFERTIME_BEFORE_DELAY 500
  113. #define RENDERER_INTERFACE_SIZE 16
  114. #define SECURE_RENDERER_INTERFACE_SIZE 5
  115. // forward decl.
  116. class HXPlayer;
  117. class CHXEvent;
  118. class CHXEventList;
  119. class HXClientEngine;
  120. class Plugin2Handler;
  121. class CBufferManager;
  122. class SourceInfo;
  123. class HXUpgradeCollection;
  124. struct IHXPacket;
  125. struct IHXStreamSource;
  126. struct IHXValues;
  127. struct IHXStream;
  128. struct IHXClientEngine;
  129. struct IHXPlayer;
  130. struct IHXPrivateStreamSource;
  131. struct IHXDigitalRightsManager;
  132. // if you change these two constants please change
  133. // ProtocolName and StreamName size in RaCOnnectionInfo
  134. // structure in hxtypes.h as well...
  135. #define MAX_STREAM_NAME 50
  136. #define MAX_PROTOCOL_NAME 20
  137. #define HX_EOF_TIME 0 // use to indicate to netplay to play until EOF of stream
  138. #define RAM_MIMETYPE "application/ram"
  139. // XXXTW. There is a copy of this in rpplmrgrpplmgr.cpp.  Update both,
  140. //  if either.
  141. enum PlayMode
  142. {
  143.     NORMAL_PLAY = 0,
  144.     BUFFERED_PLAY,
  145.     PERFECT_PLAY,
  146.     BUFFERED_PLAY_NOT_ENTIRE_CLIP,
  147.     PERFECT_PLAY_NOT_ENTIRE_CLIP
  148. };
  149. enum TurboPlayMode
  150. {
  151.     TURBO_PLAY_UNKNOWN,
  152.     TURBO_PLAY_ON,
  153.     TURBO_PLAY_OFF
  154. };
  155. enum TurboPlayOffReason
  156. {
  157.     TP_OFF_BY_UNKNOWN = 0,
  158.     TP_OFF_BY_PREFERENCE,
  159.     TP_OFF_BY_SERVER,
  160.     TP_OFF_BY_REBUFFER,
  161.     TP_OFF_BY_NOTENOUGHBW,
  162.     TP_OFF_BY_NETCONGESTION,
  163.     TP_OFF_BY_NONRTSP,
  164.     TP_OFF_BY_LIVE,
  165.     TP_OFF_BY_ROB,
  166.     TP_OFF_BY_INVALIDTLC,
  167.     TP_OFF_BY_MULTISURESTREAMS    
  168. };
  169. enum EndCode
  170. {
  171.     END_UNKNOWN = 0,
  172.     END_DURATION,
  173.     END_STOP,
  174.     END_RECONNECT,
  175.     END_REDIRECT,
  176.     END_ABORT
  177. };
  178. struct TurboPlayStats
  179. {
  180.     TurboPlayOffReason tpOffReason;
  181.     BOOL bBufferDone;
  182.     UINT32 ulAcceleratedBW;
  183.     UINT32 ulBufferedTime;
  184.     TurboPlayStats()
  185.     {
  186. tpOffReason = TP_OFF_BY_UNKNOWN;
  187. bBufferDone = FALSE;
  188. ulAcceleratedBW = 0;
  189. ulBufferedTime = 0;
  190.     }
  191. };
  192. class HXSource : public IHXStreamSource,
  193.   public IHXPendingStatus,
  194.   public IHXRegistryID,
  195.   public IHXInfoLogger,
  196.   public IHXPrivateStreamSource,
  197.   public IHXBackChannel,
  198.   public IHXASMSource,
  199. #if defined(HELIX_FEATURE_HYPER_NAVIGATE)
  200.   public IHXHyperNavigate,
  201.   public IHXHyperNavigate2,
  202. #endif /* defined(HELIX_FEATURE_HYPER_NAVIGATE) */
  203.                   public IHXSourceBufferingStats2
  204. {
  205. protected:
  206.     LONG32 m_lRefCount;
  207.     ULONG32 m_ulStreamIndex;
  208.     HXPlayer* m_pPlayer;
  209.     
  210.     CBufferManager* m_pBufferManager;
  211.     friend class CBufferManager;
  212. public:
  213.     // statistic info.
  214.     HXClientRegistry* m_pRegistry;
  215. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  216.     StatsManager* m_pStatsManager;
  217.     SOURCE_STATS* m_pStats;
  218. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  219.     IHXValues* m_pFileHeader;
  220.     HX_BITFIELD m_bRebufferingRequired : 1;
  221.     HX_BITFIELD m_bRTSPRuleFlagWorkAround : 1;
  222.     HX_BITFIELD m_bReSetup : 1;
  223.     HX_BITFIELD m_bFastStart : 1;
  224.     EndCode m_srcEndCode;
  225.     TurboPlayStats m_turboPlayStats;
  226.     TurboPlayMode m_serverTurboPlay;
  227.     HX_BITFIELD m_bSureStreamClip : 1;
  228.     SourceInfo* m_pSourceInfo;
  229.     UINT32 m_ulMaxBandwidth;
  230.     UINT32 m_ulDelay;    
  231.     UINT32 m_ulOriginalDuration;
  232.     UINT32 m_ulOriginalDelay;
  233.     UINT32 m_ulPrefetchDelay;
  234.     UINT32 m_ulRegistryID;
  235.     UINT32 m_ulTurboPushDown;
  236.     CHXSimpleList               m_PacketBufferList;
  237.     HX_BITFIELD                 m_bContinueWithHeaders : 1;
  238. protected:
  239.     HX_BITFIELD m_bDefaultAltURL : 1;
  240. public:
  241. HXSource(void);
  242.     /*
  243.      * IUnknown methods
  244.      */
  245.     STDMETHOD(QueryInterface) (THIS_
  246. REFIID riid,
  247. void** ppvObj);
  248.     STDMETHOD_(ULONG32,AddRef) (THIS);
  249.     STDMETHOD_(ULONG32,Release) (THIS);
  250.     /*
  251.      * IHXStreamSource methods
  252.      */
  253.     /************************************************************************
  254.      * Method:
  255.      * IHXStreamSource::IsLive
  256.      * Purpose:
  257.      * Ask the source whether it is live
  258.      *
  259.      */
  260.     STDMETHOD_ (BOOL,IsLive) (THIS);
  261.     
  262.     /************************************************************************
  263.      * Method:
  264.      *     IHXStreamSource::GetPlayer
  265.      * Purpose:
  266.      *     Get the interface to the player of which the source is
  267.      *     a part of.
  268.      *
  269.      */
  270.     STDMETHOD(GetPlayer) (THIS_
  271. REF(IHXPlayer*)    pPlayer);
  272.     /************************************************************************
  273.      * Method:
  274.      *     IHXStreamSource::GetContext
  275.      * Purpose:
  276.      *     Get the interface to the context of which the source is
  277.      *     a part of.
  278.      *
  279.      */
  280.     STDMETHOD(GetContext) (THIS_
  281. REF(IUnknown*) pContext);
  282.     /************************************************************************
  283.      * Method:
  284.      *     IHXStreamSource::GetURL
  285.      * Purpose:
  286.      *     Get the URL for this source. NOTE: The returned string is
  287.      *     assumed to be valid for the life of the IHXStreamSource from which it
  288.      *     was returned.
  289.      *
  290.      */
  291.     STDMETHOD_(const char*,GetURL)  (THIS);
  292.     /************************************************************************
  293.      * Method:
  294.      *     IHXStreamSource::GetStreamCount
  295.      * Purpose:
  296.      *     Returns the current number of stream instances supported by
  297.      *     this source instance.
  298.      */
  299.     STDMETHOD_(UINT16, GetStreamCount)(THIS);
  300.     /************************************************************************
  301.      * Method:
  302.      *     IHXStreamSource::GetStream
  303.      * Purpose:
  304.      *     Returns the Nth stream instance supported by this source.
  305.      */
  306.     STDMETHOD(GetStream) (THIS_
  307. UINT16 nIndex,
  308. REF(IUnknown*) pUnknown);
  309.     /************************************************************************
  310.      * Method:
  311.      * HXSource::ReportError
  312.      * Purpose:
  313.      * The protocol object reports of any fatal errors. 
  314.      *
  315.      */
  316.     void ReportError (HX_RESULT theErr);
  317.     // IHXPendingStatus methods
  318.     /************************************************************************
  319.      * Method:
  320.      *     IHXPendingStatus::GetStatus
  321.      * Purpose:
  322.      *     Called by the user to get the current pending status from an object
  323.      */
  324.     STDMETHOD(GetStatus) (THIS_
  325. REF(UINT16) uStatusCode, 
  326. REF(IHXBuffer*) pStatusDesc, 
  327. REF(UINT16) ulPercentDone) = 0;
  328.     /*
  329.      * IHXRegistryID methods
  330.      */
  331.     /************************************************************************
  332.      * Method:
  333.      *     IHXRegistryID::GetID
  334.      * Purpose:
  335.      *     Get registry ID(hash_key) of the objects(player, source and stream)
  336.      *
  337.      */
  338.     STDMETHOD(GetID) (THIS_
  339. REF(UINT32) /*OUT*/  ulRegistryID) = 0;
  340.     // IHXPrivateStreamSource methods 
  341.     STDMETHOD_ (BOOL,IsSaveAllowed) (THIS);
  342.     /*
  343.      * IHXBackChannel method
  344.      */
  345.     /************************************************************************
  346.      * Method:
  347.      *     IHXBackChannel::PacketReady
  348.      * Purpose:
  349.      *      A back channel packet sent from Renderer to FileFormat plugin.
  350.      */
  351.     STDMETHOD(PacketReady) (THIS_
  352. IHXPacket* pPacket);
  353.     /*
  354.      * IHXASMSource methods
  355.      */
  356.     /************************************************************************
  357.      * Method:
  358.      *     IHXASMSource::Subscribe
  359.      * Purpose:
  360.      *      Called to inform a file format that a subscription has occurred,
  361.      *     to rule number uRuleNumber, for stream uStreamNumber.
  362.      */
  363.     STDMETHOD(Subscribe) (THIS_
  364. UINT16 uStreamNumber,
  365. UINT16 uRuleNumber);
  366.     /************************************************************************
  367.      * Method:
  368.      *     IHXASMSource::Unsubscribe
  369.      * Purpose:
  370.      *      Called to inform a file format that a unsubscription has occurred,
  371.      *     to rule number uRuleNumber, for stream uStreamNumber.
  372.      */
  373.     STDMETHOD(Unsubscribe) (THIS_
  374. UINT16 uStreamNumber,
  375. UINT16 uRuleNumber);
  376.     // IHXInfoLogger method
  377.     /************************************************************************
  378.      * Method:
  379.      *     IHXInfoLogger::LogInformation
  380.      * Purpose:
  381.      *     Logs any user defined information in form of action and 
  382.      *     associated data.
  383.      */
  384.     STDMETHOD(LogInformation) (THIS_
  385. const char* /*IN*/ pAction,
  386. const char* /*IN*/ pData) = 0;
  387. #if defined(HELIX_FEATURE_HYPER_NAVIGATE)
  388.     /*
  389.      * IHXHyperNavigate methods
  390.      */
  391.     /************************************************************************
  392.      * Method:
  393.      *     IHXHyperNavigate::GoToURL
  394.      * Purpose:
  395.      *     Performs a simple Go To URL operation.
  396.      */
  397.     STDMETHOD(GoToURL)     (THIS_
  398.     const char* pURL,
  399.     const char* pTarget);
  400.     /************************************************************************
  401.      * Method:
  402.      *     IHXHyperNavigate2::Execute
  403.      * Purpose:
  404.      *     
  405.      * Parameters:
  406.      *      pURL:     URL (absolute or relative)
  407.      *     pTargetInstance:
  408.      *     pTargetApplication: 
  409.      *     pTargetRegion:
  410.      *     pParams:
  411.      */
  412.     STDMETHOD(Execute)     (THIS_
  413.     const char* pURL,
  414.     const char* pTargetInstance,
  415.     const char* pTargetApplication,
  416.     const char* pTargetRegion,
  417.     IHXValues* pParams);
  418. #endif /* defined(HELIX_FEATURE_HYPER_NAVIGATE) */
  419.     /************************************************************************
  420.      * Method:
  421.      *     IHXSourceBufferingStats2::GetCurrentBuffering
  422.      * Purpose:
  423.      *     Get the current buffering information
  424.      */
  425.     STDMETHOD(GetCurrentBuffering) (THIS_ 
  426.                                     UINT16  uStreamNumber,
  427.                                     REF(INT64)  llLowestTimestamp, 
  428.                                     REF(INT64)  llHighestTimestamp,
  429.                                     REF(UINT32) ulNumBytes,
  430.                                     REF(BOOL)   bDone) PURE;
  431.     /************************************************************************
  432.      * Method:
  433.      *     IHXSourceBufferingStats2::GetTotalBuffering
  434.      * Purpose:
  435.      *     Get the total amount of data buffered for a stream.
  436.      *      This includes what is in the transport buffer and in
  437.      *      the renderer
  438.      */
  439.     
  440.     STDMETHOD(GetTotalBuffering)  (THIS_ UINT16  uStreamNumber,
  441.    REF(INT64)  llLowestTimestamp, 
  442.    REF(INT64)  llHighestTimestamp,
  443.    REF(UINT32) ulNumBytes,
  444.    REF(BOOL)   bDone);
  445.     HX_RESULT Init(HXPlayer * player, UINT32 unRegistryID);
  446.     HX_RESULT SetupRegistry(void);
  447.     virtual HX_RESULT UpdateRegistry(UINT32 ulRegistryID) = 0;
  448.     virtual BOOL  IsInitialized(void) {return m_bInitialized;};
  449.     virtual BOOL IsPreBufferingDone(void) {return m_bIsPreBufferingDone;};
  450.     void AddHXStream(HXStream* pStream);
  451.     HX_RESULT CollectAudioStreams(CHXSimpleList*& pAudioStreamList);
  452.     void RemoveAudioStreams(void);
  453.     void PauseAudioStreams(void);
  454.     void ResumeAudioStreams(void);
  455.     void ReleaseAudioStreams(CHXSimpleList* pAudioStreamList);
  456.     void InitialBufferingDone(void);
  457.     void DoRebuffer(void);
  458.     BOOL IsRebufferRequired(void);
  459.     BOOL IsRebufferDone(void);
  460.     
  461. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  462.     virtual HX_RESULT CopyMetaDataToRegistry(IHXValues* pHeader);
  463. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  464.     virtual HX_RESULT DoCleanup(EndCode endCode = END_STOP);
  465.     void Stop(void);
  466.     virtual HX_RESULT DoSeek( ULONG32 seekTime) = 0;
  467.     
  468.     virtual HX_RESULT DoPause(void) = 0;
  469.     virtual HX_RESULT DoResume(void) = 0;
  470.     virtual HX_RESULT StartInitialization(void) = 0;
  471.     virtual UINT16 GetNumStreams(void) = 0;
  472.     
  473.     virtual HX_RESULT GetStreamInfo(ULONG32 ulStreamNumber,
  474.       STREAM_INFO*& theStreamInfo) = 0;
  475.     
  476.     virtual HX_RESULT GetEvent(UINT16 usStreamNumber, CHXEvent * &theEvent) = 0;
  477.     virtual HX_RESULT UpdateStatistics(void) = 0;
  478.     virtual void SetMinimumPreroll(ULONG32 ulMinimumAudioPreroll, ULONG32 ulMinimumStartingPreroll);
  479.     virtual HX_RESULT GetStreamHeaderInfo(UINT16 index, 
  480.     IHXValues * &hdr);
  481.     
  482.     virtual HX_RESULT     ProcessIdle(void) // calls _ProcessIdle (FALSE)
  483.     {
  484. return _ProcessIdle(FALSE);
  485.     }
  486. #if defined (__MWERKS__)
  487.     virtual HX_RESULT     ProcessIdleAtInterrupt(void) // calls _ProcessIdle (TRUE)
  488.     {
  489. return _ProcessIdle(TRUE);
  490.     }
  491. #endif // (__MWERKS__)
  492.     HX_RESULT GetLastError(void) { return mLastError;};
  493.     virtual BOOL IsLocalSource()  {return TRUE;};
  494.     virtual BOOL IsPNAProtocol()  {return FALSE;};
  495.     virtual BOOL IsSimulatedNetworkPlayback()  {return FALSE;};
  496.     
  497.     virtual void EventReady(CHXEvent* pEvent);
  498.     // to set and get flags for livestream, saveas, perfectplay...
  499.     virtual void SetFlags(UINT16 flags);
  500.     virtual UINT16 GetFlags() {return mFlags;};
  501.     virtual BOOL IsPerfectPlayAllowed() { return m_bPerfectPlayAllowed;};
  502.     virtual BOOL IsPerfectPlay()        { return m_bPerfectPlay;};
  503.    
  504.     virtual HX_RESULT SetPlayTimes(UINT32 ulStartTime, 
  505.      UINT32 ulEndTime, 
  506.      UINT32 ulDelay, 
  507.      UINT32 ulDuration);
  508.     virtual HX_RESULT UpdatePlayTimes(IHXValues* pValues); 
  509.     virtual BOOL IsSourceDone() = 0;
  510.     // tell about end of source...
  511.     virtual void SetEndOfClip(BOOL bForcedEndofClip = FALSE) = 0;
  512.     virtual void EnterBufferedPlay(void) {};
  513.     virtual void LeaveBufferedPlay(void) {};
  514.     ULONG32 GetDuration() const { return m_ulDuration; };
  515.     IHXClientEngine* GetClientEngine() const { return (IHXClientEngine*) m_pEngine; };
  516.    
  517.     UINT32  GetStartTime() const { return m_ulStartTime; };
  518.     UINT32  GetEndTime()   const { return m_ulEndTime; }; 
  519.     UINT32  GetDelay()   const { return m_ulDelay; };
  520.     CHXURL* GetCHXURL() { return m_pURL; };
  521.     BOOL IsDelayed() const   { return m_bDelayed; };
  522.     BOOL IsSeekable() const {return !m_bNonSeekable;};
  523.     BOOL IsPaused() const {return m_bPaused;};
  524.     INT64 GetLastExpectedPacketTime() const 
  525.     {return m_llLastExpectedPacketTime;};
  526.     
  527.     void PartOfNextGroup(BOOL bPartOfNextGroup) { m_bPartOfNextGroup = bPartOfNextGroup;};
  528.     BOOL IsPartOfNextGroup(void) { return m_bPartOfNextGroup; };
  529.     void PartOfPrefetchGroup(BOOL bPartOfPrefetchGroup) { m_bPartOfPrefetchGroup = bPartOfPrefetchGroup;};
  530.     BOOL IsPartOfPrefetchGroup(void) { return m_bPartOfPrefetchGroup; };
  531.     STDMETHOD(ReportRebufferStatus) (THIS_
  532. UINT16 uStreamNumber,
  533. UINT8 unNeeded, 
  534. UINT8 unAvailable);
  535.     STDMETHOD(SetGranularity) (THIS_
  536. UINT16 uStreamNumber,
  537. ULONG32 ulGranularity);
  538.     void SetSourceInfo(SourceInfo* pSourceInfo)  
  539.     {m_pSourceInfo = pSourceInfo;};
  540.     virtual void AdjustClipBandwidthStats(BOOL bActivate = FALSE) = 0;
  541.     virtual BOOL CanBeResumed(void)  = 0;
  542.     BOOL isRestrictedLiveStream() {return m_bRestrictedLiveStream;};
  543.     virtual BOOL TryResume(void);
  544.     virtual char* GetHost() {return NULL;};
  545.     virtual void ReSetup(void) = 0;
  546.     BOOL IsResumePending() { return m_bResumePending;};
  547.     virtual char* GetAltURL(BOOL& bDefault);
  548.     void SetAltURLType(BOOL bDefault) { m_bDefaultAltURL = bDefault; };
  549.     BOOL IsActive(void) {return m_bIsActive;};
  550.     HX_RESULT SetRequest(const CHXURL* pURL, BOOL bAltURL);
  551.     HX_RESULT GetRequest(REF(IHXRequest*) pRequest)
  552. {
  553.     pRequest = m_pRequest;
  554.     if (m_pRequest)
  555.     {
  556. m_pRequest->AddRef();
  557.     }
  558.     return HXR_OK;
  559. };
  560.     void UpdateDuration(UINT32 ulDuration);
  561.     void UpdateDelay(UINT32 ulDelay);
  562.     void ScheduleProcessCallback();
  563.     void MergeUpgradeRequest(BOOL bAddDefault = FALSE, char* pUpgradeString = NULL);
  564.     void ClearUpgradeRequest();
  565.             void                DeleteAllEvents();
  566.     void EnterPrefetch(PrefetchType prefetchType, UINT32 ulPrefetchValue);
  567.     virtual void LeavePrefetch(void);
  568.     virtual BOOL IsPrefetchDone(void) {return TRUE;};
  569.     void SetSoundLevel(UINT16 uSoundLevel, BOOL bReflushAudioDevice);
  570.     void SetAudioDeviceReflushHint(void);
  571.             void                SetMaxPossibleAccelRatio(double maxR) {m_maxPossibleAccelRatio = maxR;};
  572.     virtual void EnterFastStart(void) { m_bFastStart = TRUE; };
  573.     virtual void LeaveFastStart(TurboPlayOffReason leftReason);
  574.     virtual BOOL CanBeFastStarted(void) {return FALSE;};
  575.     virtual HX_RESULT FillRecordControl() = 0;
  576.     BOOL IsPlayingFromRecordControl() { return m_bPlayFromRecordControl; };
  577.             HX_RESULT OnTimeSync(ULONG32 ulCurrentTime);
  578. protected:
  579.     virtual  ~HXSource(void);
  580.     PRIVATE_DESTRUCTORS_ARE_NOT_A_CRIME
  581.     virtual HX_RESULT _ProcessIdle(BOOL atInterrupt = FALSE) = 0;
  582.     
  583.     virtual HX_RESULT ReadPreferences(void);
  584.     BOOL IsAudioStreamFromThisSource(IHXValues* pAudioHeader);
  585.     BOOL IsAnyAudioStream(void);
  586.     HX_RESULT DeleteStreamTable(void);
  587.     IHXValues* GetHeaderInfo(UINT16 stream_number);
  588.     ULONG32 GetAvailableMemory();
  589.     ULONG32 GetPerfectPlayTime(void);
  590.     HX_RESULT AdjustClipTime(void);
  591.     CHXMapLongToObj* GetStreamInfoTable(void)
  592.     {
  593. return mStreamInfoTable;
  594.     };
  595.     virtual void ReBuffer(void) = 0;
  596.     void GenerateFakeLostPacket(CHXEvent*& theEvent);
  597.     BOOL ShouldConvert(const char* pTargetInstance);
  598.             HX_RESULT SendHeaderToRecordControl(BOOL bFileHeader, IHXValues* pHeader);
  599.             void        ProcessFileHeader(void);
  600.             HX_RESULT   ProcessStreamHeaders(IHXValues* pHeader, STREAM_INFO*& pStreamInfo);
  601.     HX_RESULT mLastError;
  602.     CHXMapLongToObj*            mStreamInfoTable;
  603.     
  604.     // Preferences
  605.     ULONG32 m_ulPerfectPlayTime;
  606.     ULONG32 m_ulBufferedPlayTime;
  607.     ULONG32         m_ulStreamHeadersExpected;
  608.     UINT16 m_nSeeking;
  609.     BOOL m_bPerfectPlayEntireClip;
  610.     HX_BITFIELD m_bCannotBufferEntireClip : 1;
  611.     BOOL m_bPerfectPlay;
  612.     HX_BITFIELD m_bBufferedPlay : 1;
  613.     HX_BITFIELD m_bClipTimeAdjusted : 1;
  614.     HX_BITFIELD m_bInitialized : 1;
  615.     HX_BITFIELD m_bIsPreBufferingDone : 1;
  616.     HX_BITFIELD m_bAltURL : 1;
  617.     HX_BITFIELD m_bReceivedData : 1;
  618.     HX_BITFIELD m_bReceivedHeader : 1;
  619.     HX_BITFIELD m_bInitialBuffering : 1;
  620.     HX_BITFIELD m_bCustomEndTime : 1;
  621.     HX_BITFIELD m_bCustomDuration : 1;
  622.     HX_BITFIELD m_bPaused : 1;
  623.     HX_BITFIELD m_bFirstResume : 1;
  624.     HX_BITFIELD m_bResumePending : 1;
  625.     HX_BITFIELD m_bIsActive : 1;
  626.     HX_BITFIELD m_bDelayed : 1;
  627.     HX_BITFIELD m_bLocked : 1;
  628.     
  629.     HX_BITFIELD m_bPartOfNextGroup : 1;
  630.     HX_BITFIELD m_bPartOfPrefetchGroup : 1;
  631.     HX_BITFIELD m_bPrefetch : 1;
  632.     HX_BITFIELD m_bPerfectPlayAllowed : 1;
  633.     HX_BITFIELD mSaveAsAllowed : 1;
  634.     HX_BITFIELD mLiveStream : 1;
  635.     HX_BITFIELD m_bRestrictedLiveStream : 1;
  636.     HX_BITFIELD m_bNonSeekable : 1;
  637.     HX_BITFIELD m_bSourceEnd : 1; // == 1 no more packets for this stream from actual source
  638.     HX_BITFIELD m_bForcedSourceEnd : 1; // Forced end of source due to end or dur tag in url/SMIL
  639.     HX_BITFIELD m_bIsPreBufferingStarted : 1;
  640.     HX_BITFIELD m_bIsMeta: 1;
  641.     UINT32 m_ulTurboStartActiveTime;
  642.     UINT16 mFlags;
  643.     UINT16 m_uNumStreams; // Number of streams in the source...
  644.     ULONG32 m_ulPreRollInMs; // Number of millisecs worth of data to be held back (for preroll)
  645.     ULONG32 m_ulPreRoll; // Number of bytes worth of data to be held back (for preroll)    
  646.     ULONG32 m_ulAvgBandwidth; // Bandwidth for this stream...
  647.     ULONG32 m_ulDuration; // duration of this stream...
  648.     
  649.     UINT32 m_ulLastBufferingCalcTime;
  650.     UINT16 m_uActiveStreams;
  651.     PrefetchType m_prefetchType;
  652.     UINT32 m_ulPrefetchValue;
  653.     char* m_pszURL;
  654.     CHXURL* m_pURL;
  655.     UINT32 m_ulStartTime;
  656.     UINT32 m_ulEndTime;    
  657.     INT64 m_llLastExpectedPacketTime;
  658.     UINT32 m_ulRestrictedDuration;
  659.     UINT32 m_ulLossHack;
  660.     UINT32 m_ulNumFakeLostPackets;
  661.     UINT32 m_ulFirstPacketTime;
  662.     double                      m_maxPossibleAccelRatio;
  663.     // level 3 stats
  664.     UINT32 m_ulSourceStartTime;
  665.     IHXPreferences* m_pPreferences;
  666.     IHXScheduler* m_pScheduler;
  667.     IHXRequest* m_pRequest;    
  668.     HXClientEngine* m_pEngine;
  669.     CHXSimpleList m_HXStreamList;
  670.     CHXSimpleList* m_pAudioStreamList;
  671. #if defined(HELIX_FEATURE_AUTOUPGRADE)
  672.     HXUpgradeCollection* m_pUpgradeCollection;
  673. #endif /* HELIX_FEATURE_AUTOUPGRADE */
  674.     IHXASMSource* m_pASMSource;
  675.     IHXBackChannel* m_pBackChannel;
  676.     HXRecordControl* m_pRecordControl;
  677.     BOOL m_bPlayFromRecordControl;
  678.     CHXURL*                     m_pRedirectURL;
  679.     BOOL                        m_bRedirectPending;
  680. };
  681. // Defined flags
  682. #define HX_RELIABLE_FLAG 0x0001
  683. #define HX_KEYFRAME_FLAG 0x0002
  684. #define HX_LASTFRAME_FLAG 0x0004
  685. #endif // _HX_BSOURCE