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

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

Symbian

开发平台：

Visual C++

rtsptran.h：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: rtsptran.h,v 1.16.2.1 2004/07/09 02:04:37 hubbe 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 _RTSPTRAN_H_
  51. #define _RTSPTRAN_H_
  53. //#define RDT_MESSAGE_DEBUG
  55. #include "hxengin.h"
  56. #include "hxmon.h"
  57. #include "transbuf.h"
  58. #include "statinfo.h"
  59. #include "hxsmbw.h"
  61. // GCC won't let me forward declare CHXMapLongToObj::Iterator, 
  62. // so I have to include this. -JR
  63. #include "hxmap.h"
  65. #include "packfilt.h"
  67. struct IHXScheduler;
  68. struct IHXUDPSocket;
  69. struct IHXPacket;
  70. struct IHXBuffer;
  71. struct IHXCommonClassFactory;
  72. struct IHXInternalReset;
  73. struct IHXPlayerState;
  74. struct IHXAccurateClock;
  75. struct IHXSourceBufferingStats2;
  76. class  RTSPResendBuffer;
  77. class  CHXBitset;
  78. class  HX_deque;
  79. class  Timeval;
  80. class  CHXTimestampConverter;
  81. class  TNGLatencyReportPacket;
  82. struct IHXSessionStats;
  84. class TNGDataPacket;
  85. class TNGReportPacket;
  86. class TNGACKPacket;
  87. class TNGRTTRequestPacket;
  88. class TNGRTTResponsePacket;
  89. class TNGCongestionPacket;
  90. class TNGStreamEndPacket;
  92. class RTCPBaseTransport;
  93. class RTCPUDPTransport;
  94. class RTCPTCPTransport;
  95. class RTCPPacket;
  96. class ReportHandler;
  98. const UINT32 TRANSPORT_BUF_DURATION           = 2000; // 2 seconds
  99. const UINT32 TRANSPORT_BUF_DURATION_UNDEF     = 0xffffffff;
  100. const UINT32 MAX_TRANSPORT_BUF_DURATION       = 15000;
  102. /* Note: Both port numbers MUST be even */
  103. const UINT16 MIN_UDP_PORT = 6970;
  104. const UINT16 MAX_UDP_PORT = 32000;
  106. const UINT32 MAX_UDP_PACKET = 4096; // XXXBAB - check this
  107. const UINT32 MAX_PACKET_SIZE = 1000; // XXXBAB - check this
  108. const UINT32 DEFAULT_WRAP_SEQ_NO = 0x10000;
  109. const UINT32 TNG_WRAP_SEQ_NO = 0xff00;
  110. const UINT32 TNG_MAX_SEQ_GAP = 0x00C8;
  111. const UINT16 MAX_DEQUE_SIZE = 0x8000;
  112. const UINT16 INITIAL_DEQUE_SIZE = 0x400;
  113. const UINT16 PREFETCH_START_SIZE = 0x200;
  114. const UINT16 PREFETCH_CHUNK_SIZE = 0x100;
  116. static const UINT32 RESEND_BUF_DURATION     = 15000;   // 15 seconds
  117. static const UINT32 MAX_RESEND_BUF_DURATION = 90000;
  118. static const UINT32 RESEND_BUF_GROWTH_RATE  = 2000;
  121. //XXXGLENN...needs to be a range of ports for firewalls
  122. //const UINT16 SPLITTER_RESEND_PORT = 10002;
  125. class RTSPStreamData
  126. {
  127. public:
  128.     RTSPStreamData(BOOL needReliable);
  129.     virtual ~RTSPStreamData();
  131.     UINT16   m_seqNo;
  132.     UINT16 m_reliableSeqNo;
  133.     UINT16 m_lastSeqNo;
  134.     BOOL m_bNeedReliable;
  135.     BOOL m_packetSent;
  136.     UINT16 m_streamNumber;
  137.     UINT32 m_lastTimestamp;
  138.     RTSPTransportBuffer* m_pTransportBuffer;
  139.     RTSPResendBuffer* m_pResendBuffer;
  140.     STREAM_STATS* m_pStreamStats;
  141.     BOOL m_bReceivedAllPackets;
  142.     BOOL m_bNeedToACK;
  143.     BOOL m_bFirstPacket;
  144.     BOOL m_bUsesRTPPackets;
  145.     RTSPMediaType m_eMediaType;
  146.     CHXTimestampConverter*      m_pTSConverter;
  148.     /* The core must receive packet ordered in RMA time stamp.
  149.      * This structure is initialized and used when the stream is
  150.      * is instructed to do so.  In such case RMA time stamps
  151.      * are forced to be ordered (out-of-order time stamp is forced
  152.      * to the value of the last in-order time stamp).
  153.      * The use of this structue must be accompanied with the use
  154.      * of RTP packets which preserve the original packet time stamp
  155.      * in RTPTime packet field.
  156.      */
  157.     struct TSOrderHackInfo
  158.     {
  159. TSOrderHackInfo()
  160.     : m_ulLastSentTS(0)
  161.     , m_ulLastRecvTS(0)
  162. {
  163.     ;
  164. }     
  165. UINT32 m_ulLastSentTS;
  166. UINT32  m_ulLastRecvTS;
  167.     };
  168.     TSOrderHackInfo* m_pTSOrderHack;
  169. };
  171. class RTSPStreamHandler
  172. {
  173. public:
  174.     RTSPStreamHandler(RTSPTransport* pOwner);
  175.     ~RTSPStreamHandler();
  177.     HX_RESULT        initStreamData(UINT16 streamNumber,
  178.                                      BOOL needReliable,
  179.                                      BOOL bIsSource,
  180.      INT16 rtpPayloadType,
  181.      BOOL bPushData,
  182.      UINT32 wrapSequenceNumber,
  183.      UINT32 ulBufferDepth,
  184.      BOOL bHasOutOfOrderTS = FALSE,
  185.      CHXTimestampConverter* pTSConverter = NULL,
  186.      RTSPMediaType eMediaType = RTSPMEDIA_TYPE_UNKNOWN);
  187.     RTSPStreamData*   getStreamData(UINT16 streamNumber);
  188.     HX_RESULT         createResendBuffer(UINT16 streamNumber,
  189.  UINT32 wrapSequenceNumber);
  190.     RTSPResendBuffer* getResendBuffer(UINT16 streamNumber);
  191.     RTSPStreamData*   firstStreamData();
  192.     RTSPStreamData*   nextStreamData();
  193.     BOOL              endStreamData();
  194.     UINT16            streamCount() { return (m_pStreamDataMap) ? (UINT16)m_pStreamDataMap->GetCount() : 0;};
  195.     void       AddRef()  {   m_lRefCount++; }
  196.     void       Release() {
  197.     m_lRefCount--;
  198.     if (m_lRefCount == 0)
  199. delete this;
  200. }
  202. private:
  203.     INT32 m_lRefCount;
  204.     RTSPTransport* m_pOwner;
  205.     CHXMapLongToObj* m_pStreamDataMap;
  206.     CHXMapLongToObj::Iterator streamIterator;
  207. };
  209. class RTSPTransport : public RawPacketFilter
  210. {
  211. public:
  212.     RTSPTransport (BOOL bIsSource);
  213.     virtual ~RTSPTransport  ();
  214.     STDMETHOD(QueryInterface)           (THIS_
  215.                                         REFIID riid,
  216.                                         void** ppvObj) PURE;
  217.     STDMETHOD_(ULONG32,AddRef)       (THIS) PURE;
  218.     STDMETHOD_(ULONG32,Release)      (THIS) PURE;
  221.     virtual void Done () = 0;
  222.     virtual void Reset () = 0;
  223.     virtual void Restart () = 0;
  224.     virtual RTSPTransportTypeEnum tag () = 0;
  225.     virtual void addStreamInfo (RTSPStreamInfo* pStreamInfo,
  226.  UINT32 ulBufferDepth = TRANSPORT_BUF_DURATION_UNDEF);
  227.     virtual void setSessionID (const char* pSessionID);
  228.     virtual HX_RESULT sendPacket (BasePacket* pPacket) = 0;
  229.     virtual HX_RESULT sendToResendBuffer(BasePacket* pPacket) { return HXR_OK; }
  230.     virtual HX_RESULT handlePacket (IHXBuffer* pBuffer) = 0;
  231.     virtual HX_RESULT handleMasterSync (ULONG32 ulHXTime, LONG32 lHXOffsetToMaster)
  232. { return HXR_OK; }
  233.     virtual HX_RESULT anchorSync (ULONG32 ulHXTime, ULONG32 ulNTPTime)
  234. { return HXR_OK; }
  235.     virtual HX_RESULT releasePackets () { return HXR_OK; }
  236.     virtual HX_RESULT streamDone (UINT16 streamNumber) = 0;
  237.     virtual IHXUDPSocket* getUDPSocket ();
  238.     virtual IHXUDPSocket* getMulticastSocket ();
  239.     virtual HX_RESULT sendNAKPacket (UINT16 uStreamNumber,
  240.  UINT16 uBeingSeqNo,
  241.  UINT16 uEndSeqNo)
  242. { return HXR_OK; }
  243.     virtual BOOL isNullSetup() { return FALSE; }
  244.     virtual BOOL isRTP() { return FALSE; }
  245.     virtual BOOL isReflector() { return FALSE; }
  247.     // BCM
  248.     virtual RTSPStreamHandler* GetStreamHandler(void) { HX_ASSERT(FALSE); return NULL;}
  249.     virtual void SetStreamHandler (RTSPStreamHandler* pHandler) {;}
  250. //    virtual void MulticastSetup (RTSPTransport* pTrans) {}
  251.     virtual void MulticastSetup (RTSPStreamHandler* pHandler) {}
  252.     virtual void JoinMulticast (UINT32 ulAddress, UINT32 ulPort,
  253.  IHXUDPSocket* pUDP) {};
  254.     virtual BOOL isBCM(void) { return FALSE; }
  255.     // end BCM
  256.     
  257.     UINT16  getSeqNum (UINT16 streamNumber);
  258.     UINT32  getTimestamp (UINT16 streamNumber);
  259. //    HX_RESULT setMarkerRule (UINT16 ruleNumber);
  260.     virtual HX_RESULT setFirstSeqNum (UINT16 streamNumber,
  261.  UINT16 seqNum);
  262.       
  263.     virtual void      setFirstTimeStamp (UINT16 uStreamNumber, UINT32 ulTS, 
  264.                                          BOOL bIsRaw = FALSE);
  266. // only in RTPTransport...
  267. virtual void      notifyEmptyRTPInfo(void) {;}
  268.     virtual void      setPlayRange (UINT32 ulFrom, UINT32 ulTo);
  269.     virtual HX_RESULT      setFirstPlayTime  (Timeval* pTv) {return HXR_OK;};
  270.  
  271.     HX_RESULT resetFlags (UINT16 streamNumber);
  272.     HX_RESULT getPacket (UINT16 uStreamNumber,
  273.  IHXPacket*& pPacket);
  274.     virtual HX_RESULT startPackets (UINT16 uStreamNumber);
  275.     virtual HX_RESULT stopPackets (UINT16 uStreamNumber);
  277.     HX_RESULT storePacket (IHXPacket* pPacket,
  278.                                          UINT16 uStreamNumber,
  279.  UINT16 uSeqNo,
  280.  UINT16 uReliableSeqNo,
  281.  BOOL isReliable);
  282.     HX_RESULT packetReady (HX_RESULT status,
  283.  RTSPStreamData* pStreamData,
  284.  IHXPacket* pPacket);
  285.     HX_RESULT packetReady (HX_RESULT status,
  286.  UINT16 uStreamNumber,
  287.  IHXPacket* pPacket);
  288.     RTSPTransportBuffer* getTransportBuffer(UINT16 uStreamNumber);
  289.     RTSPResendBuffer* getResendBuffer(UINT16 streamNumber);
  290.     HX_RESULT getStatus (UINT16& uStatusCode, 
  291.  IHXBuffer*& pStatusDesc, 
  292.  UINT16& ulPercentDone);
  293.     HX_RESULT GetCurrentBuffering(UINT16  uStreamNumber,
  294.     INT64&  llLowestTimestamp, 
  295.     INT64&  llHighestTimestamp,
  296.     UINT32& ulNumBytes,
  297.     BOOL&   bDone);
  299.     HX_RESULT SeekFlush (UINT16 uStreamNumber);
  301.     BOOL IsDataReceived() {return m_bIsReceivedData;};
  303.     BOOL IsSourceDone(void);
  304.     HX_RESULT initializeStatistics (UINT32 ulRegistryID);
  305.     HX_RESULT SetStatistics (UINT16 uStreamNumber, STREAM_STATS* pStats);
  306.     HX_RESULT updateStatistics (BOOL bUseRegistry = TRUE);
  307.     HX_RESULT UpdateRegistry (UINT32 ulStreamNumber,
  308.  UINT32 ulRegistryID);
  309.     INT64  getBytesSent                 () {return m_lBytesSent;}
  310.     UINT32 getPacketsSent               () {return m_ulPacketsSent;}
  311.     HX_RESULT playReset ();
  312.     virtual HX_RESULT pauseBuffers ();
  313.     virtual HX_RESULT resumeBuffers ();
  314.     HX_RESULT Init (IUnknown* pContext);
  315.     HX_RESULT SetResendBufferDepth (UINT32 uMilliseconds);
  316.  
  317.     BOOL IsInitialized ();
  318.     BOOL IsUpdated ();
  319.     UINT32 wrapSequenceNumber ();
  321.     void CheckForSourceDone (UINT16 uStreamNumber);
  322.     void HandleBufferError ();
  324.     IHXScheduler*  GetScheduler(void) {return m_pScheduler;};
  326.     virtual BOOL SupportsPacketAggregation() { return FALSE; }
  327.     virtual HX_RESULT sendPackets (BasePacket** pPacket) { return HXR_NOTIMPL; }
  329.      /*XXXMC
  330.       *Special-case handling for PV clients
  331.       */
  332.      virtual HX_RESULT sendPVHandshakeResponse(UINT8* pPktPayload)
  333.                                               { return HXR_NOTIMPL; }
  335.     //XXXGH...Fix this stuff left over from Ogre
  336.     BOOL m_bHackedRecordFlag;
  338.     IHXPlayerState* m_pPlayerState;
  339.     
  340.     void FilterPacket(IHXPacket* pPacket);
  341.     void SetFilterResponse(RawPacketFilter*);
  343.     BOOL isSparseStream(UINT16 uStreamNumber);
  345.     void GetContext(IUnknown*& pContext);
  346.     void EnterPrefetch(void) { m_bPrefetch = TRUE; };
  347.     void LeavePrefetch(void);
  349.     void EnterFastStart(void);
  350.     void LeaveFastStart(void);
  352.     inline BOOL HasPlayRequestBeenSent() { return m_bPlayRequestSent; }
  353.         
  354.     inline void SetPlayRequestSent(BOOL bValue) { m_bPlayRequestSent = bValue; }
  356.     UINT32 GetPacketsSent() { return m_ulPacketsSent; }
  357.     INT64 GetBytesSent() { return m_lBytesSent; }
  358.     UINT32 GetTotalSuccessfulResends() { return m_ulTotalSuccessfulResends; }
  359.     UINT32 GetTotalFailedResends() { return m_ulTotalFailedResends; }
  360.     UINT32 GetSendingTime() { return m_ulSendingTime; }
  361.         
  362. protected:
  363.     IUnknown* m_pContext;
  364.     IHXCommonClassFactory*      m_pCommonClassFactory;
  365.     IHXScheduler*               m_pScheduler;
  366.     IHXRTSPTransportResponse*   m_pResp;
  367.     IHXRegistry* m_pRegistry;
  368.     IHXInternalReset* m_pInternalReset;
  369.     IHXSourceBufferingStats2*           m_pSrcBufferStats;
  370.     CHXString m_sessionID;
  371.     RTSPStreamHandler* m_pStreamHandler;
  372.     BOOL                 m_bIsSource;
  373.     UINT32 m_ulRegistryID;
  374.     UINT32 m_ulPacketsSent;
  375.     INT64 m_lBytesSent;
  376.     UINT32 m_ulStartTime;
  377.     UINT32 m_ulPlayRangeFrom;
  378.     UINT32 m_ulPlayRangeTo;
  379.     BOOL m_bIsInitialized;
  380.     BOOL m_bIsUpdated;
  382.     BOOL m_bPrefetch;
  383.     BOOL m_bFastStart;
  384.     BOOL m_bIsReceivedData;
  385.     BOOL m_bSourceDone;
  386.     UINT32 m_wrapSequenceNumber;
  387.     // actual multicast sender
  388.     BOOL m_bMulticast;    
  389.     
  390.     RawPacketFilter* m_pPacketFilter;
  391.     CHXSimpleList*  m_pClientPacketList;
  392.     BOOL                                m_bPlayRequestSent;
  394.     UINT32                              m_ulTotalSuccessfulResends; 
  395.     UINT32                              m_ulTotalFailedResends;
  396.     UINT32                              m_ulSendingTime;
  398.     BOOL m_drop_packets;
  399.     UINT32 m_packets_since_last_drop;    
  401.     BOOL                                m_bSkipTimeAdjustment;
  402. #ifdef RDT_MESSAGE_DEBUG
  403.     BOOL      m_bRDTMessageDebug;
  404.     CHXString m_RDTmessageDebugFileName;
  405.     void RDTmessageFormatDebugFileOut(const char* fmt, ...);
  406. #endif // RDT_MESSAGE_DEBUG
  407. };
  409. inline IHXUDPSocket*
  410. RTSPTransport::getUDPSocket()
  411. {
  412.     return 0;
  413. }
  415. inline IHXUDPSocket*
  416. RTSPTransport::getMulticastSocket()
  417. {
  418.     return 0;
  419. }
  421. inline BOOL
  422. RTSPTransport::IsInitialized()
  423. {
  424.     return m_bIsInitialized;
  425. }
  427. inline BOOL
  428. RTSPTransport::IsUpdated()
  429. {
  430.     return m_bIsUpdated;
  431. }
  433. inline UINT32
  434. RTSPTransport::wrapSequenceNumber()
  435. {
  436.     return m_wrapSequenceNumber;
  437. }
  439. #endif /* ndef _RTSPTRAN_H_ */