开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
hxntsrc.h
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：16k
源码类别：

Symbian

开发平台：

C/C++

hxntsrc.h：源码内容
  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 ***** */ 
  36. #ifndef _HX_NET_SOURCE_
  37. #define _HX_NET_SOURCE_
  39. struct IHXPacket;
  40. struct IHXPendingStatus;
  41. #include "hxpac.h"
  42. #include "pacutil.h"
  43. #include "ihxcookies.h"
  44. #include "ihxcookies2.h"
  45. #include "hxbsrc.h"
  46. #include "hxsrc.h"
  47. #include "hxprotocol.h"
  48. #include "hxstrutl.h"
  49. #include "hxbufctl.h"
  51. typedef enum
  52. {
  53.     NETSRC_READY,
  54.     // PAC
  55.     NETSRC_PACREADY,
  56.     NETSRC_PACPENDING,
  57.     // Preferred Transport
  58.     NETSRC_TRANSPORTREADY,
  59.     NETSRC_TRANSPORTPENDING,
  60.     // Reconnect
  61.     NETSRC_RECONNECTSTARTED,
  62.     NETSRC_RECONNECTPENDING,
  63.     NETSRC_RECONNECTFORCED
  64. } NetSourceState;
  66. typedef enum
  67. {
  68.     PUSHDOWN_NONE = 0,
  69.     PUSHDOWN_AUDIO_DONE,
  70.     PUSHDOWN_VIDEO_DONE,
  71.     PUSHDOWN_ALL_DONE
  72. } PushDownStatus;
  74. class ReconnectCallback;
  76. class HXNetSource :  public HXSource
  77.      ,public IHXPreferredTransportSink
  78.      ,public IHXProxyAutoConfigCallback
  79. {
  80. public:
  81. HXNetSource(void);
  83. STDMETHOD(QueryInterface) (THIS_
  84. REFIID riid,
  85. void** ppvObj);
  87. STDMETHOD_(ULONG32,AddRef) (THIS);
  89. STDMETHOD_(ULONG32,Release) (THIS);
  91. // IHXPendingStatus methods
  93. /************************************************************************
  94. * Method:
  95. *     IHXPendingStatus::GetStatus
  96. * Purpose:
  97. *     Called by the user to get the current pending status from an object
  98. */
  99. STDMETHOD(GetStatus) (THIS_
  100. REF(UINT16) uStatusCode, 
  101. REF(IHXBuffer*) pStatusDesc, 
  102. REF(UINT16) ulPercentDone);
  103. /*
  104.  * IHXRegistryID methods
  105.  */
  107. /************************************************************************
  108.  * Method:
  109.  *     IHXRegistryID::GetID
  110.  * Purpose:
  111.  *     Get registry ID(hash_key) of the objects(player, source and stream)
  112.  *
  113.  */
  114. STDMETHOD(GetID) (THIS_
  115. REF(UINT32) /*OUT*/  ulRegistryID);
  117. /************************************************************************
  118.  * Method:
  119.  *     IHXInfoLogger::LogInformation
  120.  * Purpose:
  121.  *     Logs any user defined information in form of action and 
  122.  *     associated data.
  123.  */
  124. STDMETHOD(LogInformation)     (THIS_
  125.     const char* /*IN*/ pAction,
  126.     const char* /*IN*/ pData);
  128. /*
  129.  * IHXPreferredTransportSink methods
  130.  */
  131. STDMETHOD(TransportSucceeded)     (TransportMode /* IN */   prefTransportType,
  132.     UINT16 /* IN */   uCloakPort);
  134. STDMETHOD(TransportFailed)     (THIS);
  136. HX_RESULT Setup(  const char* host, 
  137. const char* resource,
  138. UINT16  port, 
  139. BOOL  LossCorrection,
  140. const CHXURL* pURL,
  141. BOOL bAltURL);
  143.         /************************************************************************
  144.          * Method:
  145.          *     IHXSourceBufferingStats::GetCurrentBuffering
  146.          * Purpose:
  147.          *     Get the current buffering information
  148.          */
  150.         STDMETHOD(GetCurrentBuffering) (THIS_ 
  151.                                         UINT16  uStreamNumber,
  152.                                         REF(INT64)  llLowestTimestamp, 
  153.                                         REF(INT64)  llHighestTimestamp,
  154.                                         REF(UINT32) ulNumBytes,
  155.                                         REF(BOOL)   bDone);
  157. /*
  158.  *  IHXProxyAutoConfigCallback methods
  159.  */
  160. /************************************************************************
  161. *  Method:
  162. *      IHXProxyAutoConfigCallback::GetProxyInfoDone
  163. *  Purpose:
  164. */
  165. STDMETHOD(GetProxyInfoDone) (THIS_
  166. HX_RESULT   status,
  167. char*     pszProxyInfo);
  169. HXNetSource(HXPlayer* player);
  171.         virtual HX_RESULT DoCleanup(EndCode endCode = END_STOP);
  173. virtual HX_RESULT DoSeek(ULONG32 seekTime);
  175. virtual HX_RESULT DoPause(void);
  177. virtual HX_RESULT DoResume(void);
  179. virtual HX_RESULT StartInitialization(void);
  181. virtual UINT16 GetNumStreams(void);
  183. virtual HX_RESULT GetStreamInfo(ULONG32 ulStreamNumber,
  184.       STREAM_INFO*& theStreamInfo);
  186. virtual HX_RESULT GetEvent(UINT16 usStreamNumber, CHXEvent*& theEvent);
  188. ////// Interface to the Protocol object...
  189. virtual HX_RESULT FileHeaderReady(IHXValues* pHeader);
  191. virtual HX_RESULT TACInfoFromHeader(IHXValues* pValues);
  193.         BOOL CanSendToDataCallback(IHXPacket* packet) const;
  194. virtual HX_RESULT DataCallback(IHXPacket* packet);
  196. virtual HX_RESULT HeaderCallback(IHXValues* header);
  198. // tell about end of source...
  199. virtual void SetEndOfClip(BOOL bForcedEndofClip = FALSE);
  201. // The protocol object needs to know the current playback time
  202. // for a retry()
  203. virtual ULONG32 GetCurrentPlayTime(void);
  205. // set various options received from server...
  206. virtual HX_RESULT SetOption(UINT16 option, void* value);
  208. virtual HX_RESULT SetCookie(IHXBuffer* pCookie);
  210. // for auto transport switch... protocol object needs to tell
  211. // what protocol are we actually using to get data...
  212. virtual HX_RESULT TransportStarted(TransportMode mode);
  214. virtual HX_RESULT HandleRetry(char* pszHost, UINT16 ulPort);
  216. virtual BOOL CheckTransportTimeout(ULONG32 ulTime);
  217. ////// End of Interface to the Protocol object...
  219. virtual BOOL IsLocalSource() { return FALSE; };
  220. virtual BOOL IsPNAProtocol()  {return (BOOL) (!m_bRTSPProtocol);};
  222. virtual void StartDataWait(BOOL bConnectionWait = FALSE);
  223. virtual void StopDataWait();
  224. virtual void FirstDataArrives();
  226. HX_RESULT SetRedirectURL(char* pHost, UINT16 nPort, char* pPath, CHXURL* pURL);
  227. HX_RESULT SetReconnectInfo(IHXValues* pValues);
  229.         BOOL IsSourceDone(void);
  230. BOOL IsPlaying();
  232. void SetNoLatency();
  234. void EnterBufferedPlay(void);
  235. void LeaveBufferedPlay(void);
  237. void statistics_cat(char* stats,LONG32 Data);
  239. void Initialize();
  241. void SetAuthenicationInfo(const char* pszUserName, const char* pszPassword)
  242. {
  243.     memset(m_szUserName, 0, MAX_DISPLAY_NAME);
  244.     memset(m_szPassword, 0, MAX_DISPLAY_NAME);
  246.     if (pszUserName) SafeStrCpy(m_szUserName, pszUserName, MAX_DISPLAY_NAME);
  247.     if (pszPassword) SafeStrCpy(m_szPassword, pszPassword, MAX_DISPLAY_NAME);
  248. };
  250. void GetAuthenicationInfo(char** pszUserName, char** pszPassword)
  251.      {
  252.     *pszUserName = &m_szUserName[0];
  253.     *pszPassword = &m_szPassword[0];
  255.     m_bResendAuthenticationInfo = FALSE;
  256. };
  258. BOOL IsAuthenticationInfoResended(void)
  259. {
  260.     return m_bResendAuthenticationInfo;
  261. };
  264. void AdjustClipBandwidthStats(BOOL bActivate = FALSE);
  266. BOOL CanBeResumed(void);
  268. virtual HX_RESULT UpdateRegistry(UINT32 ulRegistryID);
  269. virtual void LeavePrefetch(void);
  270. virtual BOOL IsPrefetchDone(void) { return !m_bPrefetch; };
  272. virtual void EnterFastStart(void);
  273. virtual void LeaveFastStart(TurboPlayOffReason leftReason);
  274. virtual BOOL CanBeFastStarted(void);
  276. virtual HX_RESULT FillRecordControl();
  278. protected:
  280. virtual  ~HXNetSource(void);
  282. PRIVATE_DESTRUCTORS_ARE_NOT_A_CRIME
  284. HX_RESULT UpdateStatistics(void);
  286. HX_RESULT _ProcessIdle(BOOL atInterrupt = 0);
  288. virtual HX_RESULT   _ProcessIdleExt(BOOL atInterrupt = 0);
  289. virtual HX_RESULT   PreFileHeaderReadyExt(IHXValues* pHeader);
  290. virtual HX_RESULT   PostFileHeaderReadyExt(void);
  291. virtual HX_RESULT   PreHeaderCallbackExt(IHXValues* theHeader);
  292. virtual HX_RESULT   PostHeaderCallbackExt(IHXValues* theHeader);
  294. HX_RESULT     ReadPreferences(void);
  296. HX_RESULT     CreateProtocol();
  298. HX_RESULT InitializeProtocol(void);
  300. HX_RESULT set_proxy(const char* proxy,UINT16 port);
  301. HX_RESULT cleanup_proxy(void);
  303. HX_RESULT _Initialize(void);
  305. void CalculateCurrentBuffering(void);
  306. UINT32 AdjustEventTime(STREAM_INFO* pStreamInfo, UINT32 ulTime);
  308.         void ReBuffer(void);
  310. void ResetASMSource(void);
  312. BOOL IsInCloakPortList(UINT16 uPort);
  313. BOOL IsPrefetchEnded(void);
  315. HX_RESULT IsFaststartPushdownFullfilled(REF(UINT16) uStatusCode, 
  316.       REF(UINT16) ulPercentDone);
  317. BOOL IsRARVSource(void);
  319. HX_RESULT GetEventFromProtocol(UINT16 usStreamNumber, CHXEvent*& theEvent);
  320. HX_RESULT GetEventFromRecordControl(UINT16 usStreamNumber, CHXEvent*& theEvent);
  322. // stream thinning
  323. BOOL mServerSelRecordSupport;
  324. BOOL mInterframeControlSupport;
  325. BOOL mServerHasBandwidthReport;
  326. BOOL mServerHasFrameControl;
  328. // setup parameters...
  329. char* m_pHost;
  330. char* m_pPath;
  331. char* m_pResource;
  332. UINT16 m_uPort;
  334. // proxy stuff
  335. char* m_pProxy; // host string of proxy
  336. UINT16 m_uProxyPort; // host port of proxy
  337. BOOL m_bUseProxy; // == 1, connect to proxy first
  339. char mClientID[64]; /* Flawfinder: ignore */
  340. CHXSimpleList* m_pUDPPortList;
  342. HXProtocol* m_pProto;
  344. ULONG32 m_ulStartBuffering;
  346. ULONG32 m_ulServerTimeOut;
  347. ULONG32 m_ulConnectionTimeout;
  349. float m_fReBufferPercent;
  351. // level 1, 2 stats
  352. INT32 m_lRAStreamNumber;
  354. // level 3 stats
  355. CHXSimpleList* m_pLogInfoList;
  356. UINT32 m_ulLogInfoLength;
  358. // authenication info.
  359. char m_szUserName[MAX_DISPLAY_NAME]; /* Flawfinder: ignore */
  360. char m_szPassword[MAX_DISPLAY_NAME]; /* Flawfinder: ignore */
  361. UINT16 m_uLastBuffering;
  362.         UINT16          m_uLastStatusCode;
  363. ULONG32 m_ulPerfectPlayDownloadTime;
  365. // reconnect information
  366. BOOL m_bAttemptReconnect;
  367. char* m_pszReconnectServer;
  368. char* m_pszReconnectProxy;
  369. char* m_pszReconnectURL;
  370. UINT32 m_ulReconnectProxyPort;
  371. UINT32 m_ulReconnectServerPort;
  373. // redirect information
  374. char* m_pszRedirectServer;
  375. char* m_pszRedirectResource;
  376. char* m_pszRedirectURL;
  377. UINT32 m_ulRedirectServerPort;
  379. IHXPendingStatus* m_pProtocolStatus;
  380. IHXCookies* m_pCookies;
  381. IHXCookies2* m_pCookies2;
  383. //////////////////////////////////////////////
  384. // Automatic Transport Switching Support...
  385. public:
  386.         ULONG32 m_ulUDPTimeout;
  388. protected:
  389. ULONG32 m_ulMulticastTimeout;
  390. UINT32 m_ulTCPTimeout;
  391. ULONG32 m_ulStartDataWait;
  392. ULONG32 m_ulFirstDataArrives;
  393. ULONG32 m_ulSendStatsMask;
  394. ULONG32 m_ulStatsInterval;
  395. UINT32 m_ulSeekPendingTime;
  396. UINT32 m_ulServerVersion;
  397. UINT32 m_ulTransportPrefMask;
  398.         UINT16          m_uProtocolType;
  399. TransportMode m_PreferredTransport;
  400. TransportMode m_CurrentTransport;
  402. HX_BITFIELD m_bLossCorrection : 1;
  403. HX_BITFIELD m_bAltURL : 1;
  404. HX_BITFIELD m_bRTSPProtocol : 1;
  405. HX_BITFIELD m_bDataWaitStarted : 1;
  406. HX_BITFIELD m_bConnectionWait : 1;
  407. BOOL         m_bSendStatistics;
  408. BOOL     m_bUseUDPPort;
  409. HX_BITFIELD m_bResendAuthenticationInfo : 1;
  410. HX_BITFIELD m_bTimeBased : 1;
  411. HX_BITFIELD m_bUserHasCalledResume : 1;
  412. HX_BITFIELD m_bUserHasCalledStartInit : 1;
  413. HX_BITFIELD m_bAtInterrupt : 1;
  414. HX_BITFIELD m_bBruteForceReconnected : 1;
  415. HX_BITFIELD m_bBruteForceConnectToBeDone : 1;
  416. HX_BITFIELD m_bReconnect : 1;
  417. BOOL     m_bNoLatency;
  418. HX_BITFIELD m_bNoLatencySet : 1;
  419. HX_BITFIELD m_bPerfectPlayPreferenceRead : 1;
  420. BOOL     m_bPerfectPlayErrorChecked;
  421. HX_BITFIELD m_bServerHasPerfectPlay : 1;
  422. HX_BITFIELD m_bServerHasResend : 1;
  423. HX_BITFIELD m_bInRetryMode : 1;
  424. HX_BITFIELD m_bPushDownSet : 1;
  426. HX_BITFIELD m_bRARVSource : 1;
  427. HX_BITFIELD m_bRARVSourceVerified : 1;
  429. PushDownStatus m_pushDownStatus;
  431. BOOL m_bForcePerfectPlay;
  432. BOOL m_bServerHasTransportSwitching;
  433. BOOL m_bSeekPending;
  434. UINT16* m_pCloakPortList;
  435. UINT8 m_nNumberOfCloakPorts;
  436. UINT8 m_nCurrPortIdx;
  437. UINT16 m_uCurrCloakedPort;
  439. PreferredTransportState m_prefTransportState;
  440. IHXPreferredTransport* m_pPreferredTransport;
  441. IHXPreferredTransportManager* m_pPreferredTransportManager;
  443. ReconnectCallback* m_pReconnectCallback;
  444. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  445. ReconnectCallback* m_pStatsCallback;
  446. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  448. // PAC
  449. IHXProxyAutoConfig* m_pPAC;
  450. CHXSimpleList* m_pPACInfoList;
  451. LISTPOSITION m_PACInfoPosition;
  453. NetSourceState m_state;
  455. friend class ReconnectCallback;
  457. private:
  458.         IHXBufferControl*                m_pBufferCtl;
  459.         IHXWatermarkBufferControl*       m_pWMBufferCtl;
  461. public:
  462. HX_RESULT FinishSetup();
  463. void ReSetup();
  464. void Reset();
  465.     
  466. char* GetAltURL(BOOL& bDefault);
  468. HX_RESULT switch_out_of_perfectplay();
  470. HX_RESULT handleTransportSwitch(void);
  471. HX_RESULT handleProxySwitch(HX_RESULT inError);
  472. HX_RESULT handleRedirect(void);
  473. HX_RESULT handleReconnect(void);
  475. BOOL IsNetworkAvailable();
  476. HX_RESULT AttemptReconnect();
  477. HX_RESULT StartReconnect();
  478. HX_RESULT ReportStats();
  479. HX_RESULT ProcessReconnect(STREAM_INFO* pStreamInfo);
  480. HX_RESULT EndReconnect();
  481. HX_RESULT AddToPreReconnectEventList(STREAM_INFO* pStreamInfo, CHXEvent* pEvent);
  482. void UpdateReconnectInfo(UINT32 ulPacketTime, 
  483.     BOOL& bFirstEvent,
  484.     UINT32& ulPrevPacketTime,
  485.     UINT32& ulLargestGapInPacketTime,
  486.     UINT32& ulLastPacketTime);
  488. char* GetHost() {return m_pHost;};
  490. INT32 GetRAStreamNumber()
  491. {
  492.     return m_lRAStreamNumber;
  493. };
  495. UINT32 GetFirstDataArriveTime()
  496. {
  497.     return m_ulFirstDataArrives;
  498. };
  500. UINT32 GetLogInfo(CHXSimpleList*& pLogInfoList)
  501. {
  502.     pLogInfoList = m_pLogInfoList;
  503.     return m_ulLogInfoLength;
  504. };
  506. void ReportError (HX_RESULT theErr);
  508. HX_RESULT switch_to_next_transport(HX_RESULT incomingError);
  509. void set_transport(TransportMode mode);
  511. void WritePerfectPlayToRegistry();
  512. void CreateCloakedPortList();
  514. };
  516. class ReconnectCallback : public IHXCallback
  517. {
  518. public:
  519.     HXNetSource* m_pSource;
  520.     CallbackHandle m_PendingHandle;
  521.     BOOL m_bIsStatsReportingCallback;
  522.     IHXScheduler* m_pScheduler;
  523.     UINT32 m_ulScheduleTime;
  524.     UINT32 m_ulTimeout;
  525.     BOOL m_bPaused;
  527. ReconnectCallback(HXNetSource* pSource, 
  528.   BOOL bIsStatsCallback = FALSE);
  529.     HX_RESULT ScheduleCallback(UINT32 uTimeout);
  530.     HX_RESULT PauseCallback();
  531.     HX_RESULT ResumeCallback();
  532.     HX_RESULT CancelCallback();
  533.     BOOL IsPaused() {return m_bPaused;};
  535.     /*
  536.      * IUnknown methods
  537.      */
  538.     STDMETHOD(QueryInterface) (THIS_
  539.     REFIID riid,
  540.     void** ppvObj);
  542.     STDMETHOD_(ULONG32,AddRef) (THIS);
  544.     STDMETHOD_(ULONG32,Release) (THIS);
  546.     /*
  547.      * IHXCallback methods
  548.      */
  549.     STDMETHOD(Func) (THIS);
  551. protected:
  552. ~ReconnectCallback();
  554.     LONG32 m_lRefCount;
  555. };
  556. #endif // _HX_NET_SOURCE