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

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 _HXPROTOCOL_H_
  36. #define _HXPROTOCOL_H_
  37. #include "hxcom.h"
  38. #include "hxresult.h"
  39. #include "hxmon.h"
  40. #include "statinfo.h"
  41. //#include "rmresend.h"
  42. #include "hxpreftr.h"
  43. #include "hxcredc.h"
  44. // forward decl.
  45. class HXNetSource;
  46. class CHXSimpleList;
  47. struct IHXPendingStatus;
  48. struct IHXStatistics;
  49. class  CHXEvent;
  50. typedef struct _HX_BANDWIDTH_REPORT
  51. {
  52.     UINT16  serverTimeInterval;
  53.     UINT16  playerTimeInterval;
  54.     ULONG32  numServerBytes;
  55.     ULONG32  numPlayerBytes;
  56.     ULONG32  totalServerBytes;
  57.     ULONG32  totalPlayerBytes;
  58.     ULONG32  totalServerTime;
  59.     ULONG32  totalPlayerTime;
  60. } HX_BANDWIDTH_REPORT;
  61. // these are the values passed in SetOption
  62. enum
  63. {
  64.     HX_PERFECTPLAY_SUPPORTED = 0
  65.    ,HX_RESEND_SUPPORTED
  66.    ,HX_STATS_MASK
  67.    ,HX_TRANSPORTSWITCHING_SUPPORTED
  68.    ,HX_FORCE_PERFECT_PLAY
  69.    ,HX_SELECTIVE_RECORD_SUPPORTED
  70.    ,HX_GENERIC_MESSAGE_SUPPORT
  71.    ,HX_INTERFRAME_CONTROL_SUPPORT
  72.    ,HX_BANDWIDTH_REPORT_SUPPORT
  73.    ,HX_FRAME_CONTROL_SUPPORT
  74.    ,HX_STATS_INTERVAL
  75.    ,HX_MAX_BANDWIDTH
  76.    ,HX_TURBO_PLAY
  77. };
  78. #define MIN_UDP_PORT 6970
  79. #define MAX_UDP_PORT 7170
  80. #define TEXT_BUF_SIZE 1024
  81. class HXProtocol : public IHXPendingStatus
  82. #if defined(HELIX_FEATURE_STATS)
  83.    , public IHXStatistics
  84. #endif /* HELIX_FEATURE_STATS */
  85. {
  86. public:
  87.     UINT32 m_ulRegistryID;
  88.     IHXRegistry* m_pRegistry;
  89.     
  90.     HXProtocol(HXNetSource *owner, ULONG32 ulPlatformSpecific = 0);
  91.     virtual ~HXProtocol();
  92.     LONG32 m_lRefCount;
  93.     // *** IUnknown methods ***
  94.     /* This is made PURE since PNA and RTSP may expose different interfaces...*/
  95.     STDMETHOD(QueryInterface) (THIS_
  96. REFIID riid,
  97. void** ppvObj) PURE;
  98.     STDMETHOD_(ULONG32,AddRef) (THIS) PURE;
  99.     STDMETHOD_(ULONG32,Release) (THIS) PURE;
  100.    
  101.     // functions that *MUST* be implemented by every protocol
  102.     
  103.     // IHXPendingStatus methods
  104.     /************************************************************************
  105.      * Method:
  106.      *     IHXPendingStatus::GetStatus
  107.      * Purpose:
  108.      *     Called by the user to get the current pending status from an object
  109.      */
  110.     STDMETHOD(GetStatus) (THIS_
  111. REF(UINT16) uStatusCode, 
  112. REF(IHXBuffer*) pStatusDesc, 
  113. REF(UINT16) ulPercentDone) PURE;
  114. #if defined(HELIX_FEATURE_STATS)
  115.     /*
  116.      * IHXStatistics methods
  117.      */
  118.     /************************************************************************
  119.      *  Method:
  120.      *      IHXStatistics::InitializeStatistics
  121.      *  Purpose:
  122.      *      Pass registry ID to the caller
  123.      */
  124.     STDMETHOD (InitializeStatistics) (THIS_
  125. UINT32 /*IN*/ ulRegistryID) PURE;
  126.     /************************************************************************
  127.      *  Method:
  128.      *      IHXStatistics::UpdateStatistics
  129.      *  Purpose:
  130.      *      Notify the client to update its statistics stored in the registry
  131.      */
  132.     STDMETHOD (UpdateStatistics) (THIS) PURE;
  133. #endif /* HELIX_FEATURE_STATS */
  134.     virtual HX_RESULT GetStreamStatistics (ULONG32 ulStreamNumber,
  135.  STREAM_STATS** ppStreamStats) = 0;
  136.     virtual HX_RESULT UpdateRegistry (UINT32 ulStreamNumber,
  137.  UINT32 ulRegistryID) = 0;
  138.     virtual HX_RESULT server_hello (void) = 0;
  139.     virtual HX_RESULT proxy_hello (void) = 0;
  140.     virtual HX_RESULT process  (void) = 0;
  141.     virtual HX_RESULT abort   (void) = 0;
  142.     virtual HX_RESULT   GetEvent (UINT16 usStreamNumber,
  143.  CHXEvent*& pEvent) = 0;
  144.     virtual HX_RESULT GetCurrentBuffering(UINT16  uStreamNumber,
  145.     INT64&  llLowestTimestamp, 
  146.     INT64&  llHighestTimestamp,
  147.     UINT32& ulNumBytes,
  148.     BOOL&   bDone) = 0;
  149.     // functions that should be overridden
  150.     // should be made abstract later on if we decide that these are must
  151.     // for every protocol to implement.
  152.     virtual HX_RESULT setup (const char* host,
  153.  const char* path,
  154.  UINT16 port,
  155.  BOOL LossCorrection,
  156.  BOOL bHTTPCloak,
  157.                                                  BOOL   bSDPInitiated,
  158.  UINT16 cloakPort);
  159.     virtual void initialize_members (void);
  160.     virtual HX_RESULT process_idle (BOOL atInterrupt);
  161.     virtual HX_RESULT seek (ULONG32 posArg,
  162.  ULONG32 posArg2 = 0,
  163.  UINT16 seekFrom = 0)
  164. {return HXR_OK;}
  165.     virtual HX_RESULT pause  (void)
  166. {return HXR_OK;}
  167.     virtual HX_RESULT resume (UINT32 ulEndTime = 0)
  168. {return HXR_OK;}
  169.     virtual HX_RESULT stop  (void);
  170.     virtual HX_RESULT set_proxy (const char* proxy,
  171.  UINT16 port);
  172.     virtual void send_statistics (UINT32 ulStatsMask) {};
  173.     virtual BOOL end_of_clip (void)
  174. {return mSourceEnd;}
  175.     virtual UINT16 get_protocol_version (void)
  176. {return mProtocolVersion;}
  177.     virtual const char* get_protocol_name (void)
  178. {return "";}
  179.     virtual HX_RESULT set_client_id  (char * clientID);
  180.     virtual void set_locale (UINT16 locale)
  181. {mLocale = locale;}
  182.     virtual void set_perfect_play (BOOL isPerfectPlay)
  183. {m_bPerfectPlay = isPerfectPlay;}
  184. // NOTE: set_UDP_port() now means, if in UDP mode,
  185. // use the specified port for UDP. It doesn't necessarily
  186. // mean to use UDP mode...
  187.     virtual void  set_UDP_port (void) 
  188. {mUseUDPPort = TRUE;}
  189.     virtual void set_server_timeout (ULONG32 secs)
  190. {mServerTimeout = secs;}
  191.     virtual BOOL IsPerfectPlayAllowed (void)
  192. {return m_bPerfectPlayAllowed;}
  193.     virtual BOOL IsSaveAllowed (void)
  194. {return mSaveAsAllowed;}
  195.     virtual BOOL IsLive (void)
  196. {return mLiveStream;}
  197.     virtual const char* GetLastAlertInfo (REF(UINT32) ulAlertNumber)
  198. {ulAlertNumber = m_ulLastAlert; return m_pTextBuf;}
  199.     virtual BOOL IsSourceDone(void) = 0;
  200.     virtual void EnterPrefetch (void) {m_bPrefetch = TRUE;};
  201.     virtual void LeavePrefetch (void);
  202.     virtual void EnterFastStart (void) {m_bFastStart = TRUE;};
  203.     virtual void LeaveFastStart (void) {m_bFastStart = FALSE;};
  204.     virtual void SetCloakPortAttempted (UINT16* pCloakPorts, UINT8 nCloakPorts);
  205.     virtual UINT16 GetRDTFeatureLevel (void) { return 0; };
  206. protected:
  207.     
  208.     UINT8 mProxyVersion : 8; // protocol version for proxy
  209.     // flags
  210.     HX_BITFIELD mLiveStream : 1;
  211.     HX_BITFIELD mSaveAsAllowed : 1;
  212.     HX_BITFIELD m_bPerfectPlayAllowed : 1;
  213.     HX_BITFIELD m_bPrefetch : 1;
  214.     HX_BITFIELD m_bFastStart : 1;
  215.     HX_BITFIELD m_bIsFirstResume : 1;
  216.     HX_BITFIELD mProtocolValid : 1; // does server support protocol
  217.     HX_BITFIELD m_bConnectDone : 1;
  218.     HX_BITFIELD mSourceEnd : 1; // == 1 no more data
  219.     HX_BITFIELD mUseUDPPort : 1; // user specified udp port
  220.     HX_BITFIELD mFlowControl : 1; // stop server sending data
  221.     HX_BITFIELD m_bPerfectPlay : 1; // == 1 perfect play mode
  222.     HX_BITFIELD mUseProxy : 1; // == 1 use proxy
  223.     HX_BITFIELD mUsingMulticast : 1;
  224.     HX_BITFIELD m_bHTTPOnly : 1;
  225.     HX_BITFIELD m_bPaused : 1; // == 1 pause state
  226.     HX_BITFIELD mLossCorrection : 1; // == 1 loss correction is on
  227.     HX_BITFIELD m_bAreResuming : 1;
  228.     HX_BITFIELD         m_bSDPInitiated : 1;
  229.     BOOL m_bHTTPvProxy;
  230.     UINT16 mProtocolVersion; // server/client protocol number
  231.     UINT16 mAtInterrupt; // == 1 at interrupt level
  232.     UINT16 mLocked; // semaphore for reentracy
  233.     UINT16 mLocale; // stores player id ??
  234.     UINT16 mPort; // server control port
  235.     ULONG32 mServerAddr; // server address from async dns
  236.     HXNetSource* mOwner; // ptr to HXNetSource object
  237.     char* mHost; // server host name
  238.     char* mPath; // remote file path to play
  239.     CHXSimpleList* m_pUDPPortList;
  240.     UINT16 m_uUDPPort;
  241.     ULONG32 mSendStatsMask; // stats level sent to server
  242.     char* mProxy; // proxy host name
  243.     UINT16 mProxyPort; // proxy port number
  244.     UINT16 mMulticastPort;
  245.     ULONG32 mMulticastAddr;
  246.     UINT16 mCloakPort;
  247.     INT16 mNumFlowControl; // flow control msgs from owner
  248.     ULONG32 mServerTimeout; // timeout value for server
  249.     HX_RESULT m_LastError;
  250.     IHXPreferences* m_pPreferences;
  251.     IHXCredentialsCache*    m_pCredentialsCache;
  252.     UINT32 m_ulLastAlert;
  253.     char* m_pTextBuf;
  254.     UINT16* m_pCloakPorts;
  255.     UINT8 m_nCloakPorts;
  256.     // ID info
  257.     char* m_pszClientID; // string to hold clientID
  258.     char* m_pszGUID; // string to hold GUID
  259.    
  260. //////////////////////////////////////////////
  261. // Automatic Transport Switching Support...
  262. protected:
  263.     TransportMode mCurrentTransport;
  264.     UINT32 m_ulTransportPrefMask;
  265. public:
  266.     virtual void set_transport(TransportMode mode, UINT32 ulTransportPrefMask)
  267.     {
  268. if (HTTPCloakMode == mode)
  269. {
  270.     mCurrentTransport = TCPMode;
  271. }
  272. else
  273. {
  274.     mCurrentTransport = mode;
  275. }
  276. m_ulTransportPrefMask = ulTransportPrefMask;
  277.     };
  278.     BOOL can_switch_transport()
  279.     {
  280. return FALSE;
  281.     };
  282.     HX_RESULT switch_transport(TransportMode mode)
  283.     {
  284. return HXR_INVALID_OPERATION;
  285.     };
  286. #if defined(HELIX_FEATURE_STATS) && defined(HELIX_FEATURE_REGISTRY)
  287.     void statistics_cat(char* pszStats, UINT32 ulBufLen, LONG32 lData);
  288.     void statistics_cat_ext(char* pszStats, UINT32 ulBufLen, LONG32 lData, char* pszSep, UINT32& ulCount);
  289.     HX_RESULT prepare_statistics(UINT32 ulStatsMask, char*& pszStats);
  290. #endif /* HELIX_FEATURE_STATS && HELIX_FEATURE_REGISTRY */
  291. };
  292. #endif //_HXPROTOCOL_H_