hxbsrc.h
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:26k
源码类别:

Symbian

开发平台:

Visual C++

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