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

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

Symbian

开发平台：

C/C++

rtptran.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 _RTPTRAN_H_
  37. #define _RTPTRAN_H_
  39. // #define RTP_MESSAGE_DEBUG
  41. #include "hxengin.h"
  42. #include "hxmon.h"
  43. #include "transbuf.h"
  44. #include "statinfo.h"
  45. #include "hxsmbw.h"
  46. #include "ntptime.h"
  47. #include "tconverter.h"
  48. #include "chxkeepalive.h"
  50. // GCC won't let me forward declare CHXMapLongToObj::Iterator, 
  51. // so I have to include this. -JR
  52. #include "hxmap.h"
  53. #include "hxslist.h"
  54. #include "hxqossig.h"
  55. #include "hxqos.h"
  57. #include "packfilt.h"
  59. struct IHXQoSTransportAdaptationInfo;
  60. struct IHXScheduler;
  61. struct IHXUDPSocket;
  62. struct IHXPacket;
  63. struct IHXBuffer;
  64. struct IHXCommonClassFactory;
  65. struct IHXInternalReset;
  66. struct IHXPlayerState;
  67. struct IHXAccurateClock;
  68. class  RTSPResendBuffer;
  69. class  CHXBitset;
  70. class  HX_deque;
  71. class  Timeval;
  72. class  CHXTimestampConverter;
  74. class RTCPBaseTransport;
  75. class RTCPUDPTransport;
  76. class RTCPTCPTransport;
  77. class RTCPPacket;
  78. class ReportHandler;
  80. _INTERFACE IHXQoSSignal;
  81. _INTERFACE IHXQoSSignalBus;
  82. _INTERFACE IHXQoSSignalSourceResponse;
  84. HX_RESULT
  85. FixRTPHeader(IHXCommonClassFactory* pCCF, 
  86.      IHXBuffer* pOrigBuf, 
  87.      REF(IHXBuffer*) pNewBuf, 
  88.      UINT16 unSeqNoOffset, 
  89.      UINT32 ulRTPTSOffset);
  90.      
  91. HX_RESULT
  92. FixRTCPSR(IHXCommonClassFactory* pCCF, 
  93.   IHXBuffer* pOrigBuf, 
  94.   REF(IHXBuffer*) pNewBuf, 
  95.   UINT32 ulRTPTSOffset);
  97. /* The largest number of SR records we will keep */
  98. #define LSR_HIST_SZ 64
  100. struct LSRRecord
  101. {
  102.     UINT32          m_ulSourceLSR;
  103.     UINT32          m_ulServerLSR;
  104. };
  106. /******************************************************************************
  107. *   RTP RTP RTP RTP RTP 
  108. ******************************************************************************/
  109. class RTPBaseTransport: public RTSPTransport, public IHXSourceBandwidthInfo
  110. {
  111. public:
  112.     RTPBaseTransport (BOOL bIsSource);
  113.     ~RTPBaseTransport ();
  114.     STDMETHOD(QueryInterface)           (THIS_
  115.                                         REFIID riid,
  116.                                         void** ppvObj);
  117.     STDMETHOD_(ULONG32,AddRef)       (THIS);
  118.     STDMETHOD_(ULONG32,Release)      (THIS);
  120.     /*
  121.      * IHXSourceBandwidthInfo methods
  122.      */
  123.     STDMETHOD(InitBw) (THIS_
  124. IHXBandwidthManagerInput* pBwMgr);
  126.     STDMETHOD(SetTransmitRate) (THIS_
  127. UINT32 ulBitRate);
  128.     void Done ();
  129.     RTSPTransportTypeEnum tag ()
  130.     {
  131. HX_ASSERT(!"don't call this");
  132. return RTSP_TR_NONE;
  133.     };
  134.     HX_RESULT sendPacket (BasePacket* pPacket)
  135.     {
  136. HX_ASSERT(!"don't call this");
  137. return HXR_UNEXPECTED;
  138.     }
  140.     HX_RESULT init ();
  141.     
  142.     HX_RESULT reflectPacket (BasePacket* pBasePacket, REF(IHXBuffer*)pSendBuf);
  143.     HX_RESULT makePacket (BasePacket* pPacket, REF(IHXBuffer*) pPacketBuf);
  144.     void updateQoSInfo                  (UINT32 ulBytesSent);
  147.     HX_RESULT handlePacket (IHXBuffer* pBuffer);
  148.     HX_RESULT handleMasterSync (ULONG32 ulHXTime, LONG32 lHXOffsetToMaster);
  149.     HX_RESULT anchorSync (ULONG32 ulHXTime, ULONG32 ulNTPTime);
  150.     virtual HX_RESULT handleRTCPSync (NTPTime ntpTime, ULONG32 ulRTPTime);
  151.     
  152.     HX_RESULT streamDone (UINT16 streamNumber);
  153. //    IHXUDPSocket* getUDPSocket ();
  154.     void addStreamInfo (RTSPStreamInfo* pStreamInfo,
  155.       UINT32 ulBufferDepth = TRANSPORT_BUF_DURATION_UNDEF);
  157.     /* RTP-Info */
  158.     HX_RESULT setFirstSeqNum (UINT16 streamNumber, UINT16 seqNum);
  159.     void notifyEmptyRTPInfo (void);
  160.     void setFirstTimeStamp (UINT16 uStreamNumber, UINT32 ulTS,
  161.                                          BOOL bIsRaw = FALSE);
  162.     void setPlayRange (UINT32 ulFrom, UINT32 ulTo);    
  163.     HX_RESULT setFirstPlayTime (Timeval* pTv);
  164.       
  165.     void setRTCPTransport (RTCPBaseTransport* pRTCPTran);
  166.     void Reset(){}
  167.     void Restart(){}
  168.     BOOL isRTP() { return TRUE; }
  169.     BOOL isReflector() { return (m_ulPayloadWirePacket==1); }
  171.     void SyncTimestamp (IHXPacket* pPacket);
  173.     inline BOOL isRTCPRule (UINT16 unRuleNo) 
  174.     { 
  175. return (m_bHasRTCPRule && (unRuleNo == m_RTCPRuleNumber));
  176.     }
  178.     /* XXXMC
  179.      * Special-case handling for PV clients
  180.      */
  181.     void setPVEmulationMode     (BOOL bEmulatePVSession);
  183. protected:
  184. #ifdef RTP_MESSAGE_DEBUG
  185.     void messageFormatDebugFileOut(const char* fmt, ...);
  186. #endif // RTP_MESSAGE_DEBUG
  188.     void resetStartInfoWaitQueue (void);
  190.     /*
  191.      * Marker Bit Handling Routine
  192.      */
  193.     typedef void (RTPBaseTransport::*HandleMBitFunc)(REF(UINT8),IHXPacket*,UINT16); 
  194.     inline void MBitRTPPktInfo (REF(UINT8)bMBit, IHXPacket* pPkt, UINT16 unRuleNo);
  195.     inline void MBitASMRuleNo  (REF(UINT8)bMBit, IHXPacket* pPkt, UINT16 unRuleNo);
  198.     IHXBandwidthManagerInput* m_pBwMgrInput;
  199.     IHXTransportSyncServer* m_pSyncServer;
  200.     UINT16 m_streamNumber;
  201.     INT32 m_lRefCount;
  202.     UINT8 m_rtpPayloadType;
  203.     BOOL m_bHasMarkerRule;
  204.     UINT16 m_markerRuleNumber;
  205.     BOOL m_bIsSyncMaster;
  207. #ifdef RTP_MESSAGE_DEBUG
  208.     BOOL m_bMessageDebug;
  209.     CHXString m_messageDebugFileName;
  210. #endif // RTP_MESSAGE_DEBUG
  211.        
  212.      /*
  213.       * Reflection support
  214.       */
  215.      BOOL m_bHasRTCPRule;
  216.      UINT32 m_ulPayloadWirePacket;
  217.      UINT16 m_RTCPRuleNumber;
  219.     UINT16 m_uFirstSeqNum;
  220.     UINT32 m_ulFirstRTPTS;
  221.     BOOL m_bFirstSet;
  222.     BOOL m_bWeakStartSync;
  224.     INT32 m_lTimeOffsetHX;
  225.     INT32 m_lTimeOffsetRTP;
  226.     INT32 m_lOffsetToMasterHX;
  227.     INT32 m_lOffsetToMasterRTP;
  228.     INT32 m_lSyncOffsetHX;
  229.     INT32 m_lSyncOffsetRTP;
  230.     INT32 m_lNTPtoHXOffset;
  231.     BOOL m_bNTPtoHXOffsetSet;
  233.     ULONG32 m_ulLastRTPTS;
  234.     ULONG32 m_ulLastHXTS;
  235.     ULONG32 m_ulLastRawRTPTS;
  236.     BOOL m_bLastTSSet;
  238.     CHXSimpleList m_StartInfoWaitQueue;
  239.     BOOL m_bWaitForStartInfo;
  240.     BOOL m_bAbortWaitForStartInfo;
  241.     ULONG32 m_ulStartInfoWaitStartTime;
  243.     BOOL                                m_bSSRCDetermined;
  244.     UINT32                              m_ulSSRCDetermined;
  246.     /*
  247.      * RTP-Info:  According to RFC2326, it is possible not to have one of them,
  248.      * so if it is missing, take care of it right here in transport 
  249.      */
  250.     BOOL m_bSeqNoSet;
  251.     /* m_bRTPTimeSet is used differently on the server and the client */
  252.     BOOL     m_bRTPTimeSet;
  255.     // Since client is expecting RTP timestap starting at 0, we need to offset
  256.     // it in here.  btw, this is a security risk...
  257.     UINT32 m_ulBaseTS;
  258.     Timeval* m_pFirstPlayTime;
  259.     
  261.     /* this class does everything for RTCP */
  262.     ReportHandler* m_pReportHandler;
  264.     RTCPBaseTransport* m_pRTCPTran;
  266.     BOOL m_bIsLive;
  267.     UINT32 m_ulExtensionSupport;
  269.     /*
  270.      * This stream may not have been SETUPed. 
  271.      */
  272.     BOOL m_bActive;
  274.     /* XXXMC
  275.      * Support for PV Emulation
  276.      */
  277.     BOOL                m_bEmulatePVSession;
  279.     /*
  280.      * Markerbit Handling
  281.      */
  282.     HandleMBitFunc m_pMBitHandler;
  284.     /*
  285.      * Reflector RTP-Info 
  286.      */
  287.     struct ReflectorInfo
  288.     {
  289. ReflectorInfo()
  290.     : m_unSeqNoOffset(0)
  291.     , m_ulRTPTSOffset(0)
  292. {}     
  293. UINT16 m_unSeqNoOffset;
  294. UINT32 m_ulRTPTSOffset;
  295.     } m_reflectorInfo;
  297.     UINT8           m_cLSRRead;
  298.     UINT8           m_cLSRWrite;
  299.     LSRRecord       m_LSRHistory [LSR_HIST_SZ];
  300.     UINT32          MapLSR(UINT32 ulSourceLSR);
  302.     IHXQoSTransportAdaptationInfo*      m_pQoSInfo;
  304.     friend class RTCPBaseTransport;
  305.     friend class RTCPUDPTransport;
  306.     friend class RTCPTCPTransport;
  308. private:
  309.     HX_RESULT _handlePacket(IHXBuffer* pBuffer, BOOL bIsRealTime);
  310. };
  312. /*
  313. *   NOTE:
  314. *   Each RTP transport represents a RTP session because transport is bounded to a pair
  315. *   of addr and ports.
  317. *   As it is currently implemented, RTP transport can NOT have more than one stream.
  319. *   Currently, we do NOT support RTSP/RTP multicast.  so we don't need to do a number
  320. *   of things that should be done if we were to support multicast.
  321. *   1. Maintain a table of members (instread we have just one member)
  322. *   2. Don't really need to calculate RTCP intervals (instead every 5 sec)
  324. *   There are two assumptions due to the nature of 1 to 1 or 1 to many session
  325. *   1. A server (server) never receives RTP.
  326. *   2. There is only one sender (server) in a session.
  327. */
  329. class RTPUDPTransport: public RTPBaseTransport
  330. {
  331. public:
  332.     RTPUDPTransport (BOOL bIsSource);
  333.     ~RTPUDPTransport ();
  334.     void Done ();
  335.     RTSPTransportTypeEnum tag ();
  336.     HX_RESULT init (IUnknown* pContext,
  337. IHXUDPSocket* pSocket,
  338. IHXRTSPTransportResponse* pResp);
  339.     void setForeignAddress (UINT32 foreignAddr,
  340.      UINT16 foreignPort);
  341.     HX_RESULT sendPacket (BasePacket* pPacket);
  343.     IHXUDPSocket* getUDPSocket ();
  344. //    void setRTCPTransport (RTCPUDPTransport* pRTCPTran);
  346.     /* XXXMC
  347.      * Special-case handling for PV clients
  348.      */
  349.     HX_RESULT sendPVHandshakeResponse(UINT8* pPktPayload);
  351.     HX_RESULT handlePacket(IHXBuffer* pBuffer);
  353.     void            JoinMulticast(UINT32 ulAddress, UINT32 ulPort, IHXUDPSocket* pUDP);
  354.     IHXUDPSocket*   getMulticastSocket(void);
  356. protected:
  357.     class KeepAliveCB : public IHXCallback
  358.     {
  359.     public:
  360. KeepAliveCB(RTPUDPTransport* pTransport);
  362.         /*
  363.          *      IUnknown methods
  364.          */
  365.         STDMETHOD(QueryInterface)       (THIS_
  366.                                         REFIID riid,
  367.                                         void** ppvObj);
  369.         STDMETHOD_(ULONG32,AddRef)      (THIS);
  371.         STDMETHOD_(ULONG32,Release)     (THIS);
  373.         /*
  374.          *      IHXCallback methods
  375.          */
  376.         STDMETHOD(Func)                 (THIS);
  378.     private:
  379. RTPUDPTransport* m_pTransport;
  380.         LONG32               m_lRefCount;
  381.         ~KeepAliveCB();
  382.         PRIVATE_DESTRUCTORS_ARE_NOT_A_CRIME
  383.     };
  384.     friend class KeepAliveCB;
  386.     HX_RESULT onNATKeepAlive();
  388. private:
  389.     HX_RESULT writePacket (IHXBuffer* pSendBuffer);
  391.     IHXUDPSocket*               m_pUDPSocket;
  392.     UINT32                       m_foreignAddr;
  393.     UINT16                       m_foreignPort;
  394. //    RTCPUDPTransport* m_pRTCPTran;       
  396.     CHXKeepAlive m_keepAlive;
  397.     UINT16       m_keepAliveSeq;  // Sequence # for keepalive packets
  399.     UINT32     m_ulCurrentMulticastAddress;
  400.     UINT32     m_ulCurrentMulticastPort;
  401.     IHXUDPSocket*   m_pMCastUDPSocket;
  403.     friend class RTCPBaseTransport;
  404.     friend class RTCPUDPTransport;
  405. };
  407. inline IHXUDPSocket*
  408. RTPUDPTransport::getUDPSocket()
  409. {
  410.     return m_pUDPSocket;
  411. }
  413. inline IHXUDPSocket*
  414. RTPUDPTransport::getMulticastSocket()
  415. {
  416.     return m_pMCastUDPSocket;
  417. }
  419. class RTPTCPTransport: public RTPBaseTransport
  420. {
  421. public:
  422.     RTPTCPTransport (BOOL bIsSource);
  423.     ~RTPTCPTransport     ();
  424.     void Done ();
  425.     
  426.     RTSPTransportTypeEnum tag ();
  427.     HX_RESULT init (IUnknown* pContext,
  428.   IHXTCPSocket* pSocket,
  429.   IHXRTSPTransportResponse* pResp);
  430.     void setInterleaveChannel (INT8 tcpInterleave)
  431.     {
  432. m_tcpInterleave = tcpInterleave;
  433.     }
  434.     HX_RESULT sendPacket (BasePacket* pPacket);
  436. //    HX_RESULT streamDone (UINT16 streamNumber);    
  438. //    void setRTCPTransport (RTCPTCPTransport* pRTCPTran);
  439.  protected:
  440.     IHXTCPSocket*  m_pTCPSocket;
  441.     
  442. private:
  443.     HX_RESULT writePacket          (IHXBuffer* pBuf);
  445.     INT8 m_tcpInterleave;
  447.     friend class RTCPBaseTransport;
  448.     friend class RTCPTCPTransport;
  449. };
  452. /******************************************************************************
  453. *   RTCP RTCP RTCP RTCP RTCP
  454. ******************************************************************************/
  455. class RTCPBaseTransport: public RTSPTransport,
  456.  public IHXQoSSignalSourceResponse
  457. {
  458. public:
  459.     RTCPBaseTransport (BOOL bIsSender);
  460.     ~RTCPBaseTransport ();
  461.     STDMETHOD(QueryInterface)           (THIS_
  462.                                         REFIID riid,
  463.                                         void** ppvObj);
  464.     STDMETHOD_(ULONG32,AddRef) (THIS);
  465.     STDMETHOD_(ULONG32,Release) (THIS);
  466.     void Done ();
  468.     RTSPTransportTypeEnum tag ()
  469.     {
  470. HX_ASSERT(!"don't call this");
  471. return RTSP_TR_NONE;
  472.     }
  473.     HX_RESULT sendPacket (BasePacket* pPacket)
  474.     {
  475. HX_ASSERT(!"don't call this");
  476. return HXR_UNEXPECTED;
  477.     }
  478.     HX_RESULT handlePacket (IHXBuffer* pBuffer);
  479.     HX_RESULT streamDone (UINT16 streamNumber)
  480.     {
  481. HX_ASSERT(!"don't call this");
  482. return HXR_UNEXPECTED;
  483.     }
  485.     void addStreamInfo(RTSPStreamInfo* pStreamInfo,
  486.        UINT32 ulBufferDepth = TRANSPORT_BUF_DURATION_UNDEF);
  488.     void setSSRC(UINT32 ulSSRC);
  490.     HX_RESULT init ();
  491.     void setSessionID         (const char* pSessionID);
  493.     void Reset(){}
  494.     void Restart(){}
  496.     HX_RESULT SetTSConverter(CHXTimestampConverter::ConversionFactors conversionFactors);
  498.     CHXTimestampConverter* GetTSConverter(void)    { return m_pTSConverter; }
  500.     class ReportCallback : public IHXCallback
  501.     {
  502.     public:
  503. ReportCallback (RTCPBaseTransport* pTransport);
  505.         /*
  506.          *      IUnknown methods
  507.          */
  508.         STDMETHOD(QueryInterface)       (THIS_
  509.                                         REFIID riid,
  510.                                         void** ppvObj);
  512.         STDMETHOD_(ULONG32,AddRef)      (THIS);
  514.         STDMETHOD_(ULONG32,Release)     (THIS);
  516.         /*
  517.          *      IHXCallback methods
  518.          */
  519.         STDMETHOD(Func)                 (THIS);
  521.     private:
  522. RTCPBaseTransport* m_pTransport;
  523.         LONG32               m_lReportRefCount;
  524.         ~ReportCallback ();
  525.         PRIVATE_DESTRUCTORS_ARE_NOT_A_CRIME
  526.     };
  527.     friend class ReportCallback;
  529.     virtual HX_RESULT reflectRTCP (IHXBuffer* pSendBuf) = 0;
  530.     virtual HX_RESULT sendSenderReport () = 0;
  531.     virtual HX_RESULT sendReceiverReport () = 0;
  532.     virtual HX_RESULT sendBye () = 0;
  534.     // IHXQoSSignalSourceResponse
  535.     STDMETHOD (SignalBusReady)(THIS_ HX_RESULT hResult, IHXQoSSignalBus* pBus, 
  536.        IHXBuffer* pSessionId);
  538. protected:
  539.     /* caller is responsible for freeing pSendBuf */
  540.     HX_RESULT makeSenderReport (REF(IHXBuffer*) pSendBuf);
  541.     HX_RESULT makeReceiverReport (REF(IHXBuffer*) pSendBuf);
  542.     HX_RESULT makeBye (REF(IHXBuffer*) pSendBuf);
  544.     HX_RESULT startScheduler ();
  545.     HX_RESULT stopScheduler ();
  546.     BOOL      isShedulerStarted (void) { return m_bSchedulerStarted; }
  547.     void      scheduleNextReport ();
  548.     
  549.     RTPBaseTransport* m_pDataTransport;
  550.     // XXXGo
  551.     // make sure stream number that RTCP is using is the same as the one
  552.     // in RTP
  553.     UINT16 m_streamNumber;
  554.     INT32 m_lRefCount;
  555.     BOOL m_bSendBye;
  557.     BOOL m_bSendReport;
  558.     ReportCallback* m_pReportCallback;
  559.     BOOL m_bCallbackPending;
  560.     CallbackHandle m_reportTimeoutID;
  561.     BOOL m_bSchedulerStarted;
  562.     BOOL                                m_bSendRTCP;
  564.     BOOL                                m_bSSRCDetermined;
  565.     UINT32                              m_ulSSRCDetermined;
  567.     // a random number for CNAME...
  568.     BYTE* m_pcCNAME;
  570.     /* this class does everything for RTCP */
  571.     /* and pointing to the same instance that RTPBaseTransport has */
  572.     ReportHandler* m_pReportHandler;
  574.     CHXTimestampConverter* m_pTSConverter;
  576.     /* For placing recevier reports on QoS Signal Bus */
  577.     IHXQoSSignalBus*                    m_pSignalBus;
  578.     IHXQoSSignal*                       m_pQoSSignal_RR;
  579.     IHXQoSSignal*                       m_pQoSSignal_APP;
  580.     IHXBuffer*                          m_pSessionId;
  582.     friend class RTPBaseTransport;
  583.     friend class RTPUDPTransport;
  584.     friend class RTPTCPTransport;
  585. };
  587. class RTCPUDPTransport: public RTCPBaseTransport
  588. {
  589. public:
  590.     RTCPUDPTransport (BOOL bIsSender);
  591.     ~RTCPUDPTransport ();
  592.     void Done ();
  594.     HX_RESULT init (IUnknown* pContext,
  595.      IHXUDPSocket* pSocket,
  596. RTPUDPTransport* pDataTransport,
  597. IHXRTSPTransportResponse* pResp,
  598. UINT16 streamNumber);
  599.     RTSPTransportTypeEnum tag ();
  600.     HX_RESULT streamDone (UINT16 streamNumber);
  601.     void setForeignAddress (UINT32 foreignAddr,
  602.      UINT16 foreignPort);
  603.     IHXUDPSocket* getUDPSocket ();
  605.     HX_RESULT handlePacket(IHXBuffer* pBuffer);
  607.     void            JoinMulticast(UINT32 ulAddress, UINT32 ulPort, IHXUDPSocket* pUDP);
  608.     IHXUDPSocket*   getMulticastSocket(void);
  610. protected:
  611.     class KeepAliveCB : public IHXCallback
  612.     {
  613.     public:
  614. KeepAliveCB(RTCPUDPTransport* pTransport);
  616.         /*
  617.          *      IUnknown methods
  618.          */
  619.         STDMETHOD(QueryInterface)       (THIS_
  620.                                         REFIID riid,
  621.                                         void** ppvObj);
  623.         STDMETHOD_(ULONG32,AddRef)      (THIS);
  625.         STDMETHOD_(ULONG32,Release)     (THIS);
  627.         /*
  628.          *      IHXCallback methods
  629.          */
  630.         STDMETHOD(Func)                 (THIS);
  632.     private:
  633. RTCPUDPTransport* m_pTransport;
  634.         LONG32               m_lRefCount;
  635.         ~KeepAliveCB();
  636.         PRIVATE_DESTRUCTORS_ARE_NOT_A_CRIME
  637.     };
  638.     friend class KeepAliveCB;
  640.     HX_RESULT onNATKeepAlive();
  642. private:
  643.     HX_RESULT reflectRTCP (IHXBuffer* pSendBuf);
  644.     HX_RESULT sendSenderReport ();
  645.     HX_RESULT sendReceiverReport ();
  646.     HX_RESULT sendBye ();
  648.     
  649.     IHXUDPSocket*   m_pUDPSocket;
  650.     UINT32          m_foreignAddr;
  651.     UINT16          m_foreignPort;
  653.     CHXKeepAlive    m_keepAlive;
  655.     UINT32     m_ulCurrentMulticastAddress;
  656.     UINT32     m_ulCurrentMulticastPort;
  657.     IHXUDPSocket*   m_pMCastUDPSocket;
  659.     friend class RTPBaseTransport;
  660.     friend class RTPUDPTransport;
  661. };
  663. inline IHXUDPSocket*
  664. RTCPUDPTransport::getUDPSocket()
  665. {
  666.     return m_pUDPSocket;
  667. }
  669. inline IHXUDPSocket*
  670. RTCPUDPTransport::getMulticastSocket()
  671. {
  672.     return m_pMCastUDPSocket;
  673. }
  675. class RTCPTCPTransport: public RTCPBaseTransport
  676. {
  677. public:
  678.     RTCPTCPTransport (BOOL bIsSender);
  679.     ~RTCPTCPTransport ();
  680.     void Done ();
  682.     HX_RESULT init (IUnknown* pContext,
  683.      IHXTCPSocket* pSocket,
  684. RTPTCPTransport* pDataTransport,
  685. IHXRTSPTransportResponse* pResp,
  686. UINT16 streamNumber);
  687.     void setInterleaveChannel (INT8 tcpInterleave)
  688.     {
  689. m_tcpInterleave = tcpInterleave;
  690.     }
  691.     RTSPTransportTypeEnum tag ();
  692.     HX_RESULT streamDone (UINT16 streamNumber);
  694. private:
  695.     HX_RESULT reflectRTCP (IHXBuffer* pSendBuf);
  696.     HX_RESULT sendSenderReport ();
  697.     HX_RESULT sendReceiverReport ();
  698.     HX_RESULT sendBye ();
  699.     HX_RESULT writePacket (IHXBuffer* pBuf);
  700.     
  701.     IHXTCPSocket* m_pTCPSocket;
  702.     INT8 m_tcpInterleave;
  703. //    friend class RTPBaseTransport;
  704. //    friend class RTPTCPTransport;
  705. };
  707. #endif /* ndef _RTPTRAN_H_ */