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

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

Symbian

开发平台：

C/C++

rtspclnt.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 _RTSPCLNT_H_
  37. #define _RTSPCLNT_H_
  39. #include "rtspif.h"
  40. #include "rtspbase.h"
  41. #include "rtsptran.h"
  42. #include "rtptran.h"
  43. #include "rtspmdsc.h"
  44. #include "sdptypes.h" // SdpFileType
  45. #include "hxpreftr.h"
  46. #include "hxbufctl.h" // IHXTransportBufferLimit
  47. #include "hxrtsp2.h"
  49. class RTSPClientState;
  50. class RTSPOptionsMessage;
  51. class RTSPTeardownMessage;
  52. class RTSPGetParamMessage;
  53. class RTSPSetParamMessage;
  54. class RTSPSetupMessage;
  55. class RTSPAnnounceMessage;
  56. class RTSPPlayMessage;
  57. class RTSPRedirectMessage;
  58. class RTSPParser;
  59. class RTSPClientProtocol;
  60. class CByteGrowingQueue;
  61. class HXMutex;
  62. class MIMEHeader;
  64. struct IHXKeyValueList;
  65. struct IHXValues;
  66. struct IHXStreamDescription;
  67. struct IHXPacket;
  68. struct IHXConnectionlessControl;
  69. struct IHXInterruptState;
  71. #if defined(HELIX_CONFIG_NOSTATICS)
  72. #include "globals/hxglobalptr.h"
  73. #define RTSPClientSessionManagerType const RTSPClientSessionManager* const
  74. #else
  75. #define RTSPClientSessionManagerType RTSPClientSessionManager*
  76. #endif /* defined(HELIX_CONFIG_NOSTATICS) */
  78. typedef enum
  79. {    
  80.     ALTERNATE_SERVER,
  81.     ALTERNATE_PROXY
  82. } ReconnectType;
  84. typedef enum
  85. {
  86.     ENTER_PREFETCH = 0,
  87.     LEAVE_PREFETCH,
  88.     ENTER_FASTSTART,
  89.     LEAVE_FASTSTART,
  90.     PAUSE_BUFFER,
  91.     RESUME_BUFFER
  92. } TRANSPORT_MSG;
  94. typedef struct _ReconnectInfo
  95. {
  96.     CHXString m_server;
  97.     UINT32 m_ulPort;
  98. } ReconnectInfo;
  100. typedef struct _RTSPClientProtocolInfo
  101. {
  102.     RTSPClientProtocol* m_pProt;
  103.     CHXSimpleList m_seqNoList;
  104.     CHXMapLongToObj     m_interleaveMap;
  105. } RTSPClientProtocolInfo;
  107. typedef enum _RTSPIndex
  108. {
  109.     SETUP     = 0,
  110.     REDIRECT     = 1,
  111.     PLAY     = 2,
  112.     PAUSE     = 3,
  113.     SET_PARAM     = 4,
  114.     GET_PARAM     = 5,
  115.     OPTIONS     = 6,
  116.     DESCRIBE     = 7, 
  117.     TEARDOWN     = 8,
  118.     RECORD     = 9,
  119.     ANNOUNCE     = 10
  120. } RTSPIndex;
  121. const UINT32 RTSP_TABLE_SIZE = 11;
  123. struct RTSPTableEntry
  124. {
  125.     const char* pMethod;
  126.     RTSPIndex index;
  127. };
  129. class RTSPTransportInfo
  130. {
  131. public:
  132.     RTSPTransportInfo           ();
  133.     ~RTSPTransportInfo          ();
  134.     BOOL containsStreamNumber (UINT16 streamNumber);
  135.     void addStreamNumber (UINT16 streamNumber);
  136.     RTSPTransport*              m_pTransport;
  137.     RTCPBaseTransport* m_pRTCPTransport;
  138.     UINT16                      m_sPort;
  139.     UINT16                      m_sResendPort;
  141. private:
  142.     CHXSimpleList               m_streamNumberList;
  143. };
  145. class RTSPTransportRequest
  146. {
  147. public:
  148.     RTSPTransportRequest        (RTSPTransportTypeEnum tType, UINT16 sPort);
  149.     ~RTSPTransportRequest       ();
  150.     HX_RESULT addTransportInfo  (RTSPTransport* pTransport, 
  151. RTCPBaseTransport* pRTCPTransport,
  152. UINT16 streamNumber,
  153. UINT16 sPort);
  154.     RTSPTransportInfo* getTransportInfo(UINT16 streamNumber);
  155.     void ResetTransports();
  156.     RTSPTransportInfo* getFirstTransportInfo();
  157.     RTSPTransportInfo* getNextTransportInfo();
  159.     RTSPTransportTypeEnum       m_lTransportType;
  160.     UINT16                      m_sPort;
  161.     UINT16 m_sResendPort;
  162.     INT8 m_tcpInterleave;
  163.     BOOL m_bDelete;
  165. private:
  166.     CHXSimpleList               m_transportInfoList;
  167.     LISTPOSITION m_lListPos;
  168. };
  170. class RTSPClientSession : public IHXTCPResponse, 
  171.   public IHXInterruptSafe
  172. {
  173. public:
  174.     RTSPClientSession     ();
  175.     virtual ~RTSPClientSession     ();
  177.     HX_RESULT Done     ();
  178.     HX_RESULT Init     (IUnknown* pContext,
  179.      RTSPClientProtocol* pProt,
  180.      const char* pHostName,
  181. UINT16 uPort, 
  182. UINT32 ulActualAddr,
  183. BOOL bUseProxy,
  184. BOOL bHTTPCloak,
  185. UINT16 uCloakPort);
  187.     /*
  188.      * IUnknown methods
  189.      */
  191.     STDMETHOD(QueryInterface)           (THIS_
  192. REFIID riid,
  193. void** ppvObj);
  195.     STDMETHOD_(ULONG32,AddRef)          (THIS);
  197.     STDMETHOD_(ULONG32,Release)         (THIS);
  199.     /*
  200.      *  IHXTCPResponse methods
  201.      */
  203.     STDMETHOD(ConnectDone)              (THIS_
  204. HX_RESULT status);
  206.     STDMETHOD(ReadDone)                 (THIS_
  207. HX_RESULT status,
  208. IHXBuffer* pBuffer);
  210.     STDMETHOD(WriteReady)               (THIS_
  211. HX_RESULT status);
  213.     STDMETHOD(Closed)                   (THIS_
  214. HX_RESULT status);
  216.     /*
  217.      * IHXInterruptSafe methods
  218.      */
  219.     STDMETHOD_(BOOL,IsInterruptSafe) (THIS) {return TRUE;};
  221.     HX_RESULT addProtocol     (RTSPClientProtocol* pProt);
  222.     HX_RESULT removeProtocol     (RTSPClientProtocol* pProt);
  223.     int getProtocolCount     ();
  225.     HX_RESULT setProtocolInterleave     (RTSPClientProtocol* pProt, 
  226.     INT8 interleave);
  227.     HX_RESULT setProtocolSeqNo     (RTSPClientProtocol* pProt, 
  228.     UINT32 seqNo);
  229.     HX_RESULT removeProtocolSeqNo     (RTSPClientProtocol* pProt,
  230.     UINT32 seqNo);
  231.     BOOL isEmpty     ();
  232.     IHXTCPSocket* getSocket     ();
  233.     HX_RESULT closeSocket     ();
  234.     HX_RESULT reopenSocket     (RTSPClientProtocol* pProt);
  235.     UINT32 getNextSeqNo     (RTSPClientProtocol* pProt);
  236.     BOOL HttpOnly     ();
  238.     BOOL     m_bIgnoreSession;
  239.     BOOL     m_bUseProxy;
  240.     char*     m_pForeignHost;
  241.     UINT16     m_uForeignPort;
  242.     UINT32     m_ulActualAddr;
  243.     char*     m_pActualHost;
  244.     UINT16     m_uActualPort;
  245.     UINT16     m_uCloakPort;
  246.     BOOL     m_bReopenSocket;
  247.     IUnknown*     m_pContext;
  249.     BOOL     m_bHTTPOnly;
  250.     BOOL     m_bChallengeDone;
  251.     BOOL     m_bChallengeMet;
  252.     VOLATILE BOOL     m_bIsValidChallengeT;
  253.     void ReportError(HX_RESULT);
  256. private:
  257.     HX_RESULT handleInput     (BYTE* pData, UINT32 dataLen);
  258.     RTSPClientProtocol* 
  259. findProtocolFromInterleave     (INT8 interleave);
  260.     RTSPClientProtocol* 
  261. findProtocolFromSeqNo     (UINT32 seqNo);
  262.     RTSPClientProtocol*
  263. findProtocolFromSessionID     (CHXString* pszSessionID);
  265.     void getSessionID     (RTSPMessage* pMsg, CHXString* pszSessionID);
  267.     IHXNetworkServices*     m_pNetworkServices;
  268.     IHXTCPSocket*     m_pSessionSocket;
  269.     CHXSimpleList     m_protList;
  270.     INT32             m_lRefCount;
  271.     UINT32     m_ulLastSeqNo;
  272.     CByteGrowingQueue*     m_pInQueue;
  273.     RTSPParser*     m_pParser;
  274.     BOOL     m_bSessionDone;
  275.     BOOL     m_bSetSessionCalled;
  277.     // used in Connect/ConnectDone
  278.     RTSPClientProtocol*     m_pConnectingProt;
  279.     HXMutex*     m_pMutex;
  280. };
  282. class RTSPClientSessionManager : public IUnknown
  283. {
  284. public:
  285.      ~RTSPClientSessionManager();
  286.     static RTSPClientSessionManager* instance();
  287.     BOOL isValid () { return SessionManGlobal() != NULL; }
  289.     /*
  290.      * IUnknown methods
  291.      */
  293.     STDMETHOD(QueryInterface)           (THIS_
  294. REFIID riid,
  295. void** ppvObj);
  297.     STDMETHOD_(ULONG32,AddRef)          (THIS);
  299.     STDMETHOD_(ULONG32,Release)         (THIS);
  301.     /*
  302.      * RTSPClientSessionManager methods
  303.      */
  305.     virtual HX_RESULT newSession (IUnknown* pContext,
  306.      RTSPClientProtocol* pProt,
  307.      const char* pHostName,
  308. UINT16 uPort, 
  309. UINT32 ulActualAddr,
  310. BOOL bUseProxy,
  311. BOOL bHTTPOnly,
  312. UINT16 uCloakPort);
  314.     HX_RESULT removeFromSession (RTSPClientProtocol* pProt,
  315. RTSPClientSession* pSessionRemoved);
  317.     RTSPClientSession* 
  318. findSession (UINT32 ulActualAddr,
  319. UINT16 uActualPort,
  320. BOOL bUseProxy,
  321. const char* pForeignHost,
  322. UINT16 uForeignPort,
  323. IUnknown* pContext = NULL);
  324.     CHXSimpleList* getSessionList () { return &m_sessionList; }
  325.     int     getSessionCount ();
  326.     BOOL    MatchPlayerContext (IUnknown* pNewContext, IUnknown* pKnownContext);
  328. protected:
  329. RTSPClientSessionManager();
  332.     static RTSPClientSessionManagerType zm_pSessionManager;
  334.     static RTSPClientSessionManager*& SessionManGlobal();
  336.     HXMutex* m_pMutex;
  337.     CHXSimpleList m_sessionList;
  339. private:
  340.     IHXResolver*         m_pResolver;
  341.     INT32 m_lRefCount;
  342. };
  344. class RTSPClientProtocol: public RTSPBaseProtocol, 
  345.                           public IHXRTSPClientProtocol,
  346.                           public IHXRTSPClientTransportResponse,
  347.                           public IHXPendingStatus,
  348.                           public IHXStatistics,
  349.   public IHXResolverResponse,
  350.   public IHXThinnableSource,
  351.   public IHXPacketResend,
  352.   public IHXInterruptSafe,
  353.   public IHXResendBufferControl,
  354.   public IHXTransportSyncServer,
  355.   public IHXTransportBufferLimit
  356. {
  357. public:
  358.     RTSPClientProtocol ();
  359.     ~RTSPClientProtocol ();
  361.     enum State
  362.     {
  363. INIT,
  364. READY,
  365. PLAYING,
  366. RECORDING
  367.     };
  369.     class UDPResponseHelper: public IHXUDPResponse,
  370.      public IHXInterruptSafe
  371.     {
  372.     private:
  373. LONG32 m_lRefCount;
  374. UINT16 m_nPort;
  375. RTSPClientProtocol*  m_pOwner;
  377.     public:
  378. UDPResponseHelper(RTSPClientProtocol* pParent, UINT16 nPort);
  379. ~UDPResponseHelper();
  381. /* IUnknown Interfaces */
  383. STDMETHOD(QueryInterface) (THIS_
  384. REFIID riid,
  385. void** ppvObj);
  387. STDMETHOD_(ULONG32,AddRef) (THIS);
  389. STDMETHOD_(ULONG32,Release) (THIS);
  391. /*
  392. * IHXInterruptSafe methods
  393. */
  394. STDMETHOD_(BOOL,IsInterruptSafe)(THIS) {return TRUE;};
  396. /*
  397. * IHXUDPSocket methods
  398. */
  399. STDMETHOD(ReadDone) (THIS_
  400.      HX_RESULT status,
  401. IHXBuffer* pBuffer,
  402. UINT32 ulAddr,
  403. UINT16 nPort);
  404.     };
  406.     class ConnectionCheckCallback : public IHXCallback
  407.     {
  408.     public:
  409. ConnectionCheckCallback(RTSPClientProtocol* pOwner);
  410. ~ConnectionCheckCallback();
  412.     /* IUnknown Interfaces */
  414. STDMETHOD(QueryInterface) (THIS_
  415. REFIID riid,
  416. void** ppvObj);
  418. STDMETHOD_(ULONG32,AddRef) (THIS);
  420. STDMETHOD_(ULONG32,Release) (THIS);
  422. STDMETHOD(Func) (THIS);
  424.     private:
  425. LONG32 m_lRefCount;
  426. RTSPClientProtocol*  m_pOwner;
  427.     };
  429. #ifdef _MACINTOSH
  430.     class RTSPClientProtocolCallback : public IHXCallback
  431.     {
  432.     public:
  433. RTSPClientProtocolCallback(RTSPClientProtocol* pOwner);
  434. ~RTSPClientProtocolCallback();
  436.     /* IUnknown Interfaces */
  438. STDMETHOD(QueryInterface) (THIS_
  439. REFIID riid,
  440. void** ppvObj);
  442. STDMETHOD_(ULONG32,AddRef) (THIS);
  444. STDMETHOD_(ULONG32,Release) (THIS);
  446. STDMETHOD(Func) (THIS);
  448. LONG32 m_lRefCount;
  449. RTSPClientProtocol*  m_pOwner;
  450. BOOL m_bIsCallbackPending;
  451. CallbackHandle m_Handle;
  452. IHXValues* m_pPendingRequestHeaders;
  453. CHXString m_PendingDescURL;
  454.     };
  456.     friend class RTSPClientProtocolCallback;
  457. #endif /* _MACINTOSH */
  459.     /*
  460.      * IUnknown methods
  461.      */
  463.     STDMETHOD(QueryInterface)           (THIS_
  464.                                         REFIID riid,
  465.                                         void** ppvObj);
  467.     STDMETHOD_(ULONG32,AddRef)          (THIS);
  469.     STDMETHOD_(ULONG32,Release)         (THIS);
  471.     /*
  472.      * IHXRTSPClientProtocol methods
  473.      */
  475.     STDMETHOD(Init) (THIS_
  476. IUnknown*   pContext,
  477. const char* pHostName,
  478. UINT16     foreignPort,
  479. IHXRTSPClientProtocolResponse* pClient,
  480. UINT32     initializationType,
  481. IHXValues* pSessionHeaders,
  482. IHXValues* pInfo,
  483. BOOL     bHTTPCloak,
  484. UINT16     uCloakPort,
  485. BOOL     bNoReuseConnection);
  486.     STDMETHOD(SetBuildVersion) (THIS_
  487.      const char* pVersionString);
  488.     STDMETHOD(Done) (THIS);
  489.     STDMETHOD(SendStreamDescriptionRequest)
  490. (THIS_
  491.      const char* pURL,
  492. IHXValues* pRequestHeaders);
  493.     STDMETHOD(SendStreamRecordDescriptionRequest)
  494.      (THIS_
  495. const char* pURL,
  496. IHXValues* pFileHeader,
  497. CHXSimpleList* pStreams,
  498. IHXValues* pRequestHeaders);
  499.     STDMETHOD(SendSetupRequest)
  500.     (
  501. THIS_
  502. RTSPTransportType* pTransType,
  503. UINT16 nTransTypes,
  504. IHXValues* pIHXValuesRequestHeaders
  505.     );
  507.     STDMETHOD(SendPlayRequest) (THIS_
  508. UINT32 lFrom,
  509. UINT32 lTo,
  510. CHXSimpleList* pSubscriptions);
  511.     STDMETHOD(SendRecordRequest) (THIS);
  512.     STDMETHOD(SendPauseRequest) (THIS);
  513.     STDMETHOD(SendResumeRequest) (THIS);
  514.     STDMETHOD(SendTeardownRequest) (THIS);
  515.     STDMETHOD(SendSetParameterRequest) (THIS_
  516.      UINT32 lParamType,
  517. const char* pParamName,
  518. IHXBuffer* pParamValue);
  519.     STDMETHOD(SendSetParameterRequest) (THIS_
  520.      const char* pParamName,
  521. const char* pParamValue,
  522. const char* pMimeType,
  523. const char* pContent);
  524.     STDMETHOD(SendGetParameterRequest) (THIS_
  525.      UINT32 lParamType,
  526. const char* pParamName);
  527.     STDMETHOD(SendPacket) (THIS_
  528. BasePacket* pPacket);
  529.     STDMETHOD(SendStreamDone) (THIS_
  530. UINT16 streamNumber);
  531.     STDMETHOD(SendPlayerStats) (THIS_
  532. const char* pStats);
  533.     STDMETHOD(SendKeepAlive) (THIS);
  534.     STDMETHOD(GetPacket) (THIS_
  535. UINT16 uStreamNumber,
  536. REF(IHXPacket*) pPacket);
  537.     STDMETHOD(StartPackets) (THIS_
  538. UINT16 uStreamNumber);
  539.     STDMETHOD(StopPackets) (THIS_
  540. UINT16 uStreamNumber);
  541.     STDMETHOD(SetProxy) (THIS_
  542. const char* pProxyHost,
  543. UINT16 proxyPort);
  544.     STDMETHOD(SetResponse) (THIS_
  545. IHXRTSPClientProtocolResponse* pResp);
  547.     /*
  548.      * IHXThinnableSource methods.
  549.      */
  551.     /************************************************************************
  552.      * Method:
  553.      *     IHXThinnableSource::DropByN
  554.      *  Purpose:
  555.      *
  556.      * Implemented by protocols that allow infinite thinnability through
  557.      *      LimitBandwidthByDropping
  558.      */
  560.     STDMETHOD(LimitBandwidthByDropping) (THIS_
  561. UINT32 ulStreamNo,
  562. UINT32 ulBandwidthLimit);
  564.     STDMETHOD(SetDeliveryBandwidth) (THIS_
  565. UINT32 ulBandwidth,
  566. UINT32 ulMsBackoff);
  568.     /*
  569.      * XXX...The following 3 functions had better be removed under
  570.      *       full IRMA
  571.      */
  573.     STDMETHOD_(IHXPendingStatus*, GetPendingStatus) (THIS);
  574.     STDMETHOD_(IHXStatistics*, GetStatistics) (THIS);
  575.     STDMETHOD_(BOOL, HttpOnly) (THIS);
  577.     STDMETHOD(Subscribe) (THIS_
  578.      CHXSimpleList* pSubscriptions);
  579.     STDMETHOD(Unsubscribe) (THIS_
  580.      CHXSimpleList* pUnsubscriptions);
  581.     STDMETHOD(RuleChange) (THIS_
  582.      CHXSimpleList* pRuleChanges);
  583.     STDMETHOD(BackChannelPacketReady) (THIS_
  584.      IHXPacket* pPacket);
  585.     STDMETHOD(SendRTTRequest) (THIS);
  587.     STDMETHOD(SendBWReport) (THIS_
  588.      INT32 aveBandwidth,
  589. INT32 packetLoss,
  590. INT32 bandwidthWanted);
  591.     STDMETHOD(SetFirstSeqNum) (THIS_
  592. UINT16 uStreamNumber,
  593. UINT16 uSeqNum);
  595.     STDMETHOD(SetRTPInfo) (THIS_
  596. UINT16 uStreamNumber,
  597. UINT16 uSeqNum,
  598. UINT32 ulRTPTime,
  599. RTPInfoEnum info
  600. );
  602.     STDMETHOD(InitSockets) (THIS);
  604.     STDMETHOD(GetCurrentBuffering) (THIS_
  605. UINT16     uStreamNumber,
  606. REF(INT64)  llLowestTimestamp, 
  607. REF(INT64)  llHighestTimestamp,
  608. REF(UINT32) ulNumBytes,
  609. REF(BOOL)   bDone);
  611.     STDMETHOD(SeekFlush) (THIS);
  613.     STDMETHOD_(BOOL, IsDataReceived) (THIS);
  614.     
  615.     STDMETHOD_(BOOL,IsSourceDone) (THIS);
  617.     /*
  618.      * IHXInterruptSafe methods
  619.      */
  620.     STDMETHOD_(BOOL,IsInterruptSafe) (THIS) {return TRUE;};
  622.     /*
  623.      * IHXRTSPClientTransportResponse methods
  624.      */
  626.     STDMETHOD(PacketReady) (THIS_
  627. HX_RESULT status,
  628. const char* pSessionID,
  629. IHXPacket* pPacket);
  631.     STDMETHOD(OnRTTRequest)      (THIS_
  632.                                  HX_RESULT status,
  633. const char* pSessionID
  634. );
  636.     STDMETHOD(OnRTTResponse) (THIS_
  637.      HX_RESULT status,
  638. const char* pSessionID,
  639. UINT32 ulSecs,
  640. UINT32 ulUSecs);
  642.     STDMETHOD(OnBWReport)       (THIS_
  643.                                  HX_RESULT status,
  644. const char* pSessionID,
  645. INT32 aveBandwidth,
  646. INT32 packetLoss,
  647. INT32 bandwidthWanted
  648. );
  650.     STDMETHOD(OnCongestion) (THIS_
  651.      HX_RESULT status,
  652. const char* pSessionID,
  653. INT32 xmitMultiplier,
  654. INT32 recvMultiplier);
  656.     STDMETHOD(OnACK) (THIS_
  657. HX_RESULT status,
  658. RTSPResendBuffer* pResendBuffer,
  659. UINT16 uStreamNumber,
  660. const char* pSessionID,
  661. UINT16* pAckList,
  662. UINT32 uAckListCount,
  663. UINT16* pNakList,
  664. UINT32 uNakListCount);
  666.     STDMETHOD(OnStreamDone) (THIS_
  667. HX_RESULT status,
  668. UINT16 uStreamNumber);
  670.     STDMETHOD(OnSourceDone) (THIS);
  673.     STDMETHOD(OnProtocolError) (THIS_
  674. HX_RESULT status);
  676.     /*
  677.      * IHXPendingStatus methods
  678.      */
  680.     STDMETHOD(GetStatus) (THIS_
  681. REF(UINT16) uStatusCode, 
  682. REF(IHXBuffer*) pStatusDesc, 
  683. REF(UINT16) ulPercentDone);
  684.     /*
  685.      * IHXResolverResponse methods
  686.      */
  688.     STDMETHOD(GetHostByNameDone) (THIS_
  689. HX_RESULT status,
  690. UINT32 ulAddr);
  692.     /*
  693.      * IHXStatistics methods
  694.      */
  696.     STDMETHOD (InitializeStatistics) (THIS_
  697. UINT32 /*IN*/ ulRegistryID);
  699.     STDMETHOD (UpdateStatistics) (THIS);
  701.     STDMETHOD(OnPacket) (THIS_
  702. UINT16 uStreamNumber,
  703. BasePacket** ppPacket);
  705.     STDMETHOD(SetConnectionTimeout) (THIS_
  706. UINT32 uSeconds);
  708.     STDMETHOD_(UINT16, GetProtocolType) (THIS) {return m_uProtocolType;};
  710.     STDMETHOD(InitPacketFilter) (THIS_
  711. RawPacketFilter* pFilter);
  713.     STDMETHOD(SetResendBufferDepth) (THIS_
  714. UINT32 uSeconds);
  716.     /*
  717.      * IHXTransportSyncServer methods
  718.      */
  719.     STDMETHOD(DistributeSyncAnchor) (THIS_
  720.     ULONG32 ulHXTime, 
  721.     ULONG32 ulNTPTime);
  723.     STDMETHOD(DistributeSync)     (ULONG32 ulHXTime, 
  724.     LONG32 lHXTimeOffset);
  726.     STDMETHOD(DistributeStartTime)  (ULONG32 ulHXRefTime);
  728.     /*
  729.      * IHXTransportBufferLimit methods
  730.      */
  732.     /************************************************************************
  733.      * Method:
  734.      *     IHXTransportBufferLimit::SetByteLimit
  735.      * Purpose:
  736.      *      Sets the maximum number of bytes that can be buffered in the
  737.      *      transport buffer. If incomming packets would put us over this
  738.      *      limit, then they are replaced with lost packets. A byte limit
  739.      *      of 0 means unlimited buffering.
  740.      */
  741.     STDMETHOD(SetByteLimit) (THIS_ UINT16 uStreamNumber, 
  742.      UINT32 uByteLimit);
  744.     /************************************************************************
  745.      * Method:
  746.      *     IHXTransportBufferLimit::GetByteLimit
  747.      * Purpose:
  748.      *      Returns the current byte limit in effect. A value of 0 means
  749.      *      unlimited buffering is allowed
  750.      */
  751.     STDMETHOD_(UINT32,GetByteLimit) (THIS_ UINT16 uStreamNumber);
  753.     /*
  754.      *  RTSPClientProtocol public methods
  755.      */
  757.     HX_RESULT(ReadDoneWithToPort) (
  758.      HX_RESULT status,
  759. IHXBuffer* pBuffer,
  760. UINT32 ulAddr,
  761. UINT16 nFromPort,
  762. UINT16 nToPort);
  764.     HX_RESULT HandleUnexpected (RTSPMessage* pMsg);
  765.     HX_RESULT HandleBadVersion (RTSPMessage* pMsg);
  766.     HX_RESULT HandleOptions (RTSPOptionsMessage* pMsg);
  767.     HX_RESULT HandleTeardown (RTSPTeardownMessage* pMsg);
  768.     HX_RESULT HandleGetParam (RTSPGetParamMessage* pMsg);
  769.     HX_RESULT HandleSetParam (RTSPSetParamMessage* pMsg);
  770.     HX_RESULT HandleRedirect (RTSPRedirectMessage* pMsg);
  771.     HX_RESULT HandleUseProxy (RTSPResponseMessage* pMsg);
  772.     void      SessionCreated (RTSPClientSession* pSession);
  773.     void      SessionSucceeded (RTSPClientSession* pSession, 
  774. IHXTCPSocket* pSocket);
  775.     void      SessionFailed (RTSPClientSession* pSession,
  776. IHXTCPSocket* pSocket);
  777.     HX_RESULT InitDone (HX_RESULT status);
  778.     void DoConnectionCheck ();
  779.     void GetForeignHostPort (char*& pHost, UINT16* pPort);
  780.     void SetSplitterConsumer (BOOL);
  781.     void EnterPrefetch (void) { m_bPrefetch = TRUE; };
  782.     void LeavePrefetch (void);
  783.     void EnterFastStart (void);
  784.     void LeaveFastStart (void);
  785.     void InitCloak (UINT16* pCloakPorts, UINT8 nCloakPorts, IHXValues* pValues);
  786.     UINT16 GetCloakPortSucceeded (void);
  787.     HX_RESULT SetStatistics (UINT16 uStreamNumber, STREAM_STATS* pStats);
  788.     BOOL   IsSessionSucceeded()         {return m_bSessionSucceeded;};
  789.     
  790.     HX_RESULT InitExt(IUnknown*   pContext,
  791. const char* pHostName,
  792. UINT16     foreignPort,
  793. IHXRTSPClientProtocolResponse* pClient,
  794. UINT32     initializationType,
  795. IHXValues* pSessionHeaders,
  796. IHXValues* pInfo,
  797. BOOL     bHTTPCloak,
  798. UINT16     uCloakPort,
  799. BOOL     bNoReuseConnection);
  801.     virtual UINT16 GetRDTFeatureLevel(void){ return 0; };
  803.     friend class RTSPClientSession;
  805.     void ReportError( HX_RESULT theErr );
  806. protected:
  807.     HX_RESULT handleMessage (RTSPMessage* pMsg);
  808.     HX_RESULT handleTCPData (BYTE* pData, UINT16 dataLen, UINT16 channel);
  809.     HX_RESULT handleOptionsResponse (RTSPResponseMessage* pMsg);
  810.     HX_RESULT handleGetParamResponse (RTSPResponseMessage* pMsg);
  811.     HX_RESULT handleSetParamResponse (RTSPResponseMessage* pMsg);
  812.     HX_RESULT handleTeardownResponse (RTSPResponseMessage* pMsg);
  813.     HX_RESULT handlePlayResponse (RTSPResponseMessage* pMsg,
  814. RTSPPlayMessage* pPlayMsg);
  815.     HX_RESULT handleRecordResponse (RTSPResponseMessage* pMsg);
  816.     HX_RESULT handlePauseResponse (RTSPResponseMessage* pMsg);
  817.     HX_RESULT handleSetupResponse (RTSPResponseMessage* pMsg,
  818.      RTSPSetupMessage* pSetupMsg);
  819.     HX_RESULT handleDescribeResponse (RTSPResponseMessage* pMsg);
  820.     HX_RESULT handleAnnounceResponse (RTSPResponseMessage* pMsg);
  821.     HX_RESULT HandleRedirectResponse (RTSPResponseMessage* pMsg);   
  822.     HX_RESULT sendInitialMessage (RTSPClientSession* pSession,
  823. IHXTCPSocket* pSocket);
  824.     HX_RESULT addTransportMimeType (MIMEHeaderValue* pValue,
  825. UINT16 streamNumber);
  826.     HX_RESULT sendFirstSetupRequest
  827.     (
  828. IHXValues* pIHXValuesRequestHeaders
  829.     );
  830.     HX_RESULT sendRemainingSetupRequests();
  831.     HX_RESULT sendSetupRequestMessage
  832.     (
  833. RTSPStreamInfo* pStreamInfo,
  834. IHXValues* pIHXValuesRequestHeaders,
  835. BOOL bFirstSetup
  836.     );
  837.     const char* allowedMethods ();
  838.     void messageDebugFileOut            (const char* pMsg, BOOL bIncoming);
  839.     RTSPTransportRequest* getTransportRequest(MIMEHeaderValue* pValue);
  840.     void reset();
  841.     void clearTransportRequestList ();
  842.     void clearStreamInfoList ();
  843.     void clearUDPResponseHelperList ();
  844.     void clearSocketStreamMap(CHXMapLongToObj*& pSocketStreamMap);
  845.     HX_RESULT getStreamDescriptionMimeType  (char*& pMimeType);
  846.     IHXStreamDescription* 
  847.               getStreamDescriptionInstance(const char* pMimeType);
  849.     HX_RESULT closeSocket ();
  850.     HX_RESULT reopenSocket ();
  851.     HX_RESULT ReopenSocketDone (HX_RESULT status);
  853.     HX_RESULT sendPendingStreamDescription(const char* pURL,
  854.    IHXValues* pRequestHeaders);
  856.     // only for [RTP|RDT]/TCP
  857.     void mapTransportChannel (RTSPTransport* pTran, UINT16 nChannel);
  859.     // Interop - control number could be anything...
  860.     void mapControlToStreamNo (const char* pControl, UINT16 uStreamNo);
  861.     BOOL getStreamNoFromControl (const char* pControl, REF(UINT16) uStreamNo);
  863.     void    setSetupRequestURL (RTSPSetupMessage* pMsg, RTSPStreamInfo* );
  864.     RTSPStreamInfo* getStreamInfoFromSetupRequestURL(const char* pUrl);
  866.     /* interop        */
  867.     /* since Allow doesn't deal with encoder stuff, just do it here    */
  868.     /* depending on the result, we will use either old or new sdp file */
  869.     SdpFileType     GetSdpFileTypeWeNeed(IHXValues* pHeaders);
  871.     HX_RESULT       GetStreamDescriptionInfo(IUnknown* pUnknown, CHXString& mimeTypes);
  872.     void            SendMsgToTransport(TRANSPORT_MSG msg);
  873.     void            AddCommonHeaderToMsg(RTSPRequestMessage* pMsg);
  874.     HX_RESULT       SendMsgToServer(RTSPMethod msg);
  876.     HX_RESULT extractRealmInformation(RTSPResponseMessage* pMsg);
  877.     HX_RESULT extractExistingAuthorizationInformation(IHXValues* pIHXValuesRequestHeaders);
  878.     void appendAuthorizationHeaders(/*RTSPDescribeMessage*/ RTSPMessage* pMsg);
  880.     HX_RESULT RetrieveReconnectInfo(MIMEHeader*   pHeader,
  881.       ReconnectType reconnectType,
  882.       IHXValues*&  pReconnectValues);
  884.     HX_RESULT handleAuthentication(RTSPResponseMessage* pMsg);
  886.     HX_RESULT   ParseSDP(const char* pszContentType, IHXBuffer* pSDPBuffer);
  887.     void        RemoveSDPHeaders(void);
  889. #if defined(HELIX_FEATURE_TRANSPORT_MULTICAST)
  890.     BOOL        DetermineIfRMPresentation(IHXValues** ppStrmHeaders,
  891.           UINT32 ulNumStreams);
  893.     BOOL        GetSubscriptionBW(IHXValues*    pFileHeader, 
  894.           IHXValues**   ppStrmHeaders,
  895.           UINT16        unNumStrmHeaders,
  896.           REF(UINT32*)  pulSubscriptionBW,
  897.           UINT32        ulNumStreams);   
  899.     BOOL        GetRightHeaders(REF(IHXValues**)    ppRealHeaders, // out
  900.               UINT32     ulNumStreams,
  901.               IHXValues**     ppHeaders,
  902.               UINT32     cHeaders,
  903.               UINT32*             pulSubscriptionBW);
  904. #endif /* HELIX_FEATURE_TRANSPORT_MULTICAST */
  906.     BOOL        GetStreamCountNoTrust(IHXValues**   ppHeaders, 
  907.       UINT16        unNumHeader,
  908.       REF(UINT32)   ulNumStream);
  910.     HX_RESULT   CreateUDPSockets(UINT32 ulStream, UINT16 ulPort);
  912.     virtual BOOL IsRealServer(void);
  913.     virtual HX_RESULT   RetrieveChallenge(RTSPResponseMessage* pMessage);
  914.     virtual HX_RESULT sendSetupRequestMessageExt(RTSPStreamInfo* pStreamInfo, 
  915.    IHXValues*& pIHXValuesRequestHeaders,
  916.    BOOL bFirstSetup,
  917.    RTSPSetupMessage*& pMsg);
  918.     virtual HX_RESULT handleSetupResponseExt(RTSPStreamInfo* pStreamInfo,
  919.        RTSPResponseMessage* pMsg, 
  920.        RTSPSetupMessage* pSetupMsg);
  921.     virtual HX_RESULT DoSendRTTRequest(void);
  922.     virtual HX_RESULT DoSendBWReport(INT32 aveBandwidth,
  923.        INT32 packetLoss,
  924.        INT32 bandwidthWanted);
  925.     void addUAProfHeaders(IHXValues *pHeaders);
  927.     RTSPTransportBuffer* getTransportBuffer(UINT16 uStreamNumber);
  929.     virtual HX_RESULT sendRequest(RTSPRequestMessage* pMsg, UINT32 seqNo);
  930.     virtual HX_RESULT sendRequest(RTSPRequestMessage* pMsg,
  931.                                     const char* pContent,
  932.                                     const char* pMimeType, UINT32 seqNo);
  935.     LONG32                              m_lRefCount;
  936.     UINT16 m_foreignPort;
  937.     UINT32 m_foreignAddr;
  938.     UINT32                              m_ulConnectToAddr;
  939.     UINT16 m_setupResponseCount;    
  940.     IHXInterruptState* m_pInterruptState;
  941.     IHXRTSPClientProtocolResponse* m_pResp;
  942.     RTSPClientSessionManager* m_pSessionManager;
  943.     RTSPClientSession*  m_pSession;
  944.     RTSPClientProtocol::State m_state;
  945.     IHXScheduler* m_pScheduler;
  946.     IHXValues* m_pSessionHeaders;
  947.     IHXValues* m_pCloakValues;
  948.     IHXKeyValueList* m_pResponseHeaders;
  949.     IHXResolver* m_pResolver;
  950.     IHXRegistry* m_pRegistry;
  952.     CHXString m_versionString;
  953.     CHXString m_url;
  954.     CHXString m_contentBase;
  955.     CHXString m_headerControl;
  956.     CHXString m_challenge;
  957.     CHXString m_hostName;
  958.     CHXString m_proxyHost;
  959.     CHXString                           m_sessionHost;
  960.     UINT16 m_proxyPort;
  961.     UINT16* m_pCloakPorts;
  962.     UINT8 m_nCloakPorts;
  963.     CHXString m_sessionID;
  964.     IHXValues* m_pFileHeader;
  965.     CHXSimpleList m_streamInfoList;
  966.     CHXSimpleList  m_transportRequestList;
  967.     CHXSimpleList m_UDPResponseHelperList;
  968.     CHXSimpleList m_sessionList;
  969.     CHXMapLongToObj* m_pTransportStreamMap; // map streamID->trans
  970.     CHXMapLongToObj* m_pTransportPortMap; // map port->trans
  971.     CHXMapLongToObj* m_pTransportMPortMap; // map multicast port->trans
  972.     CHXMapLongToObj* m_pTransportChannelMap; // map channel->trans (only in TCP)
  973.     CHXMapLongToObj* m_pUDPSocketStreamMap; // map streamID->socket
  974.     CHXMapLongToObj* m_pRTCPSocketStreamMap; // map streamID->socket
  975.     CHXMapStringToOb* m_pControlToStreamNoMap; // streamID->streamNumber
  976.     BOOL m_bSeqValueReceived;
  977.     BOOL m_bSetupRecord;
  978.     BOOL m_bClientDone;
  979.     BOOL                                m_bMessageDebug;
  980.     BOOL m_bUseProxy;
  981.     BOOL m_bUseHTTPProxy;
  982.     BOOL m_bHTTPOnly;
  983.     BOOL m_bNoReuseConnection;
  984.     BOOL m_bLoadTest;
  985.     BOOL m_bKeepLiveResponsed;
  986.     BOOL m_bPrefetch;
  987.     BOOL m_bFastStart;
  988.     BOOL                                m_bPaused;
  989.     BOOL m_bSessionSucceeded;
  990.     IHXConnectionlessControl* m_pConnectionlessControl;
  991.     BOOL m_bConnectionlessControl;
  992.     ConnectionCheckCallback* m_pConnectionCheckCallback;    
  993.     UINT32 m_uConnectionCheckCallbackHandle;
  994.     BOOL m_bConnectionAlive;
  995.     UINT32 m_uConnectionTimeout;
  996.     BOOL m_bEntityRequired;
  997.     UINT16 m_uCloakPort;
  998.     CHXString                           m_messageDebugFileName;
  999.     HXMutex* m_pMutex;
  1000.     UINT16 m_uProtocolType;
  1001.     TransportMode m_currentTransport;
  1003.     UINT32 m_ulBufferDepth;
  1004.     BOOL m_bSplitterConsumer;
  1005.     RawPacketFilter*  m_pPacketFilter;
  1007.     BOOL m_bHasSyncMasterStream;
  1009.     IHXNetworkServices*         m_pNetworkServices;
  1010.     IHXPreferences* m_pPreferences;
  1011.     IHXBuffer* m_pUAProfURI;
  1012.     IHXBuffer* m_pUAProfDiff;
  1014.     /* Interop */
  1015.     
  1016.     // TRUE iff a server we are talking is not RS...This implies RTP..
  1017.     BOOL m_bNonRSRTP;
  1018.     IHXValues* m_pSetupRequestHeader;
  1019.     BOOL m_bPlayJustSent;
  1020.     BOOL m_bIPTV;
  1021.     BOOL m_bColumbia;
  1022.     BOOL m_bNoKeepAlive;   
  1023.     BOOL m_bForceUCaseTransportMimeType;
  1024.     BOOL m_bReportedSuccessfulTransport;
  1025.     
  1026.     BOOL                                m_bSDPInitiated;
  1027.     BOOL                                m_bMulticast;
  1028.     UINT32                              m_ulMulticastAddress;
  1029.     IHXValues*                          m_pSDPFileHeader;
  1030.     CHXSimpleList*                      m_pSDPStreamHeaders;
  1032.     BOOL m_pIsMethodSupported[RTSP_TABLE_SIZE];
  1033.     static const RTSPTableEntry zm_pRTSPTable[RTSP_TABLE_SIZE];
  1035.     class TimeoutCallback : public IHXCallback
  1036.     {
  1037.     public:
  1038. TimeoutCallback(RTSPClientProtocol* pOwner);
  1039. ~TimeoutCallback();
  1041. STDMETHOD(QueryInterface) (THIS_
  1042. REFIID riid,
  1043. void** ppvObj);
  1045. STDMETHOD_(ULONG32,AddRef) (THIS);
  1047. STDMETHOD_(ULONG32,Release) (THIS);
  1049. STDMETHOD(Func) (THIS);
  1051.     private:
  1052. LONG32         m_lRefCount;
  1053. RTSPClientProtocol*          m_pOwner;
  1054.     };
  1057.     CHXKeepAlive*                       m_pSessionTimeout;
  1058.     TimeoutCallback*                    m_pTimeoutCallback;
  1059.     BOOL                                m_bUseLegacyTimeOutMsg;
  1060.     BOOL                                m_bKeepAlivePending;
  1061.     UINT32                              m_ulServerTimeOut;
  1062.     UINT32                              m_ulCurrentTimeOut;
  1064. #if defined(_MACINTOSH)
  1065.     RTSPClientProtocolCallback* m_pCallback;
  1066. #endif /* _MACINTOSH */
  1067. };
  1069. #endif /* _RTSPCLNT_H_ */