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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
rtspclnt.h
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：33k
源码类别：

Symbian

开发平台：

Visual C++

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