rtptran.h

linux下的一款播放器

     */
    HX_RESULT sendPVHandshakeResponse(UINT8* pPktPayload);

    HX_RESULT handlePacket(IHXBuffer* pBuffer);

    void            JoinMulticast(UINT32 ulAddress, UINT32 ulPort, IHXUDPSocket* pUDP);
    IHXUDPSocket*   getMulticastSocket(void);

protected:
    class KeepAliveCB : public IHXCallback
    {
    public:
	KeepAliveCB(RTPUDPTransport* pTransport);

        /*
         *      IUnknown methods
         */
        STDMETHOD(QueryInterface)       (THIS_
                                        REFIID riid,
                                        void** ppvObj);

        STDMETHOD_(ULONG32,AddRef)      (THIS);

        STDMETHOD_(ULONG32,Release)     (THIS);

        /*
         *      IHXCallback methods
         */
        STDMETHOD(Func)                 (THIS);

    private:
	RTPUDPTransport*		m_pTransport;
        LONG32              		m_lRefCount;
        ~KeepAliveCB();
        PRIVATE_DESTRUCTORS_ARE_NOT_A_CRIME
    };
    friend class KeepAliveCB;

    HX_RESULT onNATKeepAlive();

private:
    HX_RESULT writePacket		(IHXBuffer* pSendBuffer);

    IHXUDPSocket*              	m_pUDPSocket;
    UINT32                      	m_foreignAddr;
    UINT16                      	m_foreignPort;
//    RTCPUDPTransport*			m_pRTCPTran;       

    CHXKeepAlive m_keepAlive;
    UINT16       m_keepAliveSeq;  // Sequence # for keepalive packets

    UINT32	    m_ulCurrentMulticastAddress;
    UINT32	    m_ulCurrentMulticastPort;
    IHXUDPSocket*   m_pMCastUDPSocket;

    friend class RTCPBaseTransport;
    friend class RTCPUDPTransport;
};

inline IHXUDPSocket*
RTPUDPTransport::getUDPSocket()
{
    return m_pUDPSocket;
}

inline IHXUDPSocket*
RTPUDPTransport::getMulticastSocket()
{
    return m_pMCastUDPSocket;
}

class RTPTCPTransport: public RTPBaseTransport
{
public:
    RTPTCPTransport			(BOOL bIsSource);
    ~RTPTCPTransport    		();
    void Done				();
    
    RTSPTransportTypeEnum tag		();
    HX_RESULT init			(IUnknown* pContext,
			 		IHXTCPSocket* pSocket,
			 		IHXRTSPTransportResponse* pResp);
    void setInterleaveChannel		(INT8 tcpInterleave)
    {	
	m_tcpInterleave = tcpInterleave;
    }
    HX_RESULT sendPacket		(BasePacket* pPacket);

//    HX_RESULT streamDone		(UINT16 streamNumber);    

//    void setRTCPTransport		(RTCPTCPTransport* pRTCPTran);
 protected:
    IHXTCPSocket* 			m_pTCPSocket;
    
private:
    HX_RESULT writePacket         	(IHXBuffer* pBuf);

    INT8				m_tcpInterleave;

    friend class RTCPBaseTransport;
    friend class RTCPTCPTransport;
};


/******************************************************************************
*   RTCP RTCP RTCP RTCP RTCP
******************************************************************************/
class RTCPBaseTransport: public RTSPTransport,
			 public IHXQoSSignalSourceResponse
{
public:
    RTCPBaseTransport			(BOOL bIsSender);
    ~RTCPBaseTransport			();
    STDMETHOD(QueryInterface)           (THIS_
                                        REFIID riid,
                                        void** ppvObj);
    STDMETHOD_(ULONG32,AddRef)		(THIS);
    STDMETHOD_(ULONG32,Release)		(THIS);
    void Done				();

    RTSPTransportTypeEnum tag		()
    {
	HX_ASSERT(!"don't call this");
	return RTSP_TR_NONE;
    }
    HX_RESULT sendPacket		(BasePacket* pPacket)
    {
	HX_ASSERT(!"don't call this");
	return HXR_UNEXPECTED;
    }
    HX_RESULT handlePacket		(IHXBuffer* pBuffer);
    HX_RESULT streamDone		(UINT16 streamNumber)
    {
	HX_ASSERT(!"don't call this");
	return HXR_UNEXPECTED;
    }

    void addStreamInfo(RTSPStreamInfo* pStreamInfo,
		       UINT32 ulBufferDepth = TRANSPORT_BUF_DURATION_UNDEF);

    void setSSRC(UINT32 ulSSRC);

    HX_RESULT init				();
    void setSessionID		        (const char* pSessionID);

    void Reset(){}
    void Restart(){}

    HX_RESULT SetTSConverter(CHXTimestampConverter::ConversionFactors conversionFactors);

    CHXTimestampConverter* GetTSConverter(void)    { return m_pTSConverter; }

    class ReportCallback : public IHXCallback
    {
    public:
	ReportCallback			(RTCPBaseTransport* pTransport);

        /*
         *      IUnknown methods
         */
        STDMETHOD(QueryInterface)       (THIS_
                                        REFIID riid,
                                        void** ppvObj);

        STDMETHOD_(ULONG32,AddRef)      (THIS);

        STDMETHOD_(ULONG32,Release)     (THIS);

        /*
         *      IHXCallback methods
         */
        STDMETHOD(Func)                 (THIS);

    private:
	RTCPBaseTransport*		m_pTransport;
        LONG32              		m_lReportRefCount;
        ~ReportCallback			();
        PRIVATE_DESTRUCTORS_ARE_NOT_A_CRIME
    };
    friend class ReportCallback;

    virtual HX_RESULT reflectRTCP		(IHXBuffer* pSendBuf) = 0;
    virtual HX_RESULT sendSenderReport		() = 0;
    virtual HX_RESULT sendReceiverReport	() = 0;
    virtual HX_RESULT sendBye			() = 0;

    // IHXQoSSignalSourceResponse
    STDMETHOD (SignalBusReady)(THIS_ HX_RESULT hResult, IHXQoSSignalBus* pBus, 
			       IHXBuffer* pSessionId);

protected:
    /* caller is responsible for freeing pSendBuf */
    HX_RESULT makeSenderReport		(REF(IHXBuffer*) pSendBuf);
    HX_RESULT makeReceiverReport	(REF(IHXBuffer*) pSendBuf);
    HX_RESULT makeBye			(REF(IHXBuffer*) pSendBuf);

    HX_RESULT startScheduler		();
    HX_RESULT stopScheduler		();
    BOOL      isShedulerStarted		(void)	{ return m_bSchedulerStarted; }
    void      scheduleNextReport	();
    
    RTPBaseTransport*			m_pDataTransport;
    // XXXGo
    // make sure stream number that RTCP is using is the same as the one
    // in RTP
    UINT16				m_streamNumber;
    INT32				m_lRefCount;
    BOOL				m_bSendBye;

    BOOL				m_bSendReport;
    ReportCallback*			m_pReportCallback;
    BOOL				m_bCallbackPending;
    CallbackHandle			m_reportTimeoutID;
    BOOL				m_bSchedulerStarted;
    BOOL                                m_bSendRTCP;

    BOOL                                m_bSSRCDetermined;
    UINT32                              m_ulSSRCDetermined;

    // a random number for CNAME...
    BYTE*				m_pcCNAME;

    /* this class does everything for RTCP */
    /* and pointing to the same instance that RTPBaseTransport has */
    ReportHandler*			m_pReportHandler;

    CHXTimestampConverter*		m_pTSConverter;

    /* For placing recevier reports on QoS Signal Bus */
    IHXQoSSignalBus*                    m_pSignalBus;
    IHXQoSSignal*                       m_pQoSSignal_RR;
    IHXQoSSignal*                       m_pQoSSignal_APP;
    IHXBuffer*                          m_pSessionId;

    friend class RTPBaseTransport;
    friend class RTPUDPTransport;
    friend class RTPTCPTransport;
};

class RTCPUDPTransport: public RTCPBaseTransport
{
public:
    RTCPUDPTransport			(BOOL bIsSender);
    ~RTCPUDPTransport			();
    void Done				();

    HX_RESULT init			(IUnknown* pContext,
    					IHXUDPSocket* pSocket,
					RTPUDPTransport* pDataTransport,
					IHXRTSPTransportResponse* pResp,					
					UINT16 streamNumber);
    RTSPTransportTypeEnum tag		();
    HX_RESULT streamDone		(UINT16 streamNumber);
    void setForeignAddress		(UINT32 foreignAddr,
    					UINT16 foreignPort);
    IHXUDPSocket* getUDPSocket	();

    HX_RESULT handlePacket(IHXBuffer* pBuffer);

    void            JoinMulticast(UINT32 ulAddress, UINT32 ulPort, IHXUDPSocket* pUDP);
    IHXUDPSocket*   getMulticastSocket(void);

protected:
    class KeepAliveCB : public IHXCallback
    {
    public:
	KeepAliveCB(RTCPUDPTransport* pTransport);

        /*
         *      IUnknown methods
         */
        STDMETHOD(QueryInterface)       (THIS_
                                        REFIID riid,
                                        void** ppvObj);

        STDMETHOD_(ULONG32,AddRef)      (THIS);

        STDMETHOD_(ULONG32,Release)     (THIS);

        /*
         *      IHXCallback methods
         */
        STDMETHOD(Func)                 (THIS);

    private:
	RTCPUDPTransport*		m_pTransport;
        LONG32              		m_lRefCount;
        ~KeepAliveCB();
        PRIVATE_DESTRUCTORS_ARE_NOT_A_CRIME
    };
    friend class KeepAliveCB;

    HX_RESULT onNATKeepAlive();

private:
    HX_RESULT reflectRTCP		(IHXBuffer* pSendBuf);
    HX_RESULT sendSenderReport		();
    HX_RESULT sendReceiverReport	();
    HX_RESULT sendBye			();

    
    IHXUDPSocket*   m_pUDPSocket;
    UINT32          m_foreignAddr;
    UINT16          m_foreignPort;

    CHXKeepAlive    m_keepAlive;

    UINT32	    m_ulCurrentMulticastAddress;
    UINT32	    m_ulCurrentMulticastPort;
    IHXUDPSocket*   m_pMCastUDPSocket;

    friend class RTPBaseTransport;
    friend class RTPUDPTransport;
};

inline IHXUDPSocket*
RTCPUDPTransport::getUDPSocket()
{
    return m_pUDPSocket;
}

inline IHXUDPSocket*
RTCPUDPTransport::getMulticastSocket()
{
    return m_pMCastUDPSocket;
}

class RTCPTCPTransport: public RTCPBaseTransport
{
public:
    RTCPTCPTransport			(BOOL bIsSender);
    ~RTCPTCPTransport			();
    void Done				();

    HX_RESULT init			(IUnknown* pContext,
    					IHXTCPSocket* pSocket,
					RTPTCPTransport* pDataTransport,
					IHXRTSPTransportResponse* pResp,
					UINT16 streamNumber);
    void setInterleaveChannel		(INT8 tcpInterleave)
    {
	m_tcpInterleave = tcpInterleave;
    }
    RTSPTransportTypeEnum tag		();
    HX_RESULT streamDone		(UINT16 streamNumber);

private:
    HX_RESULT reflectRTCP		(IHXBuffer* pSendBuf);
    HX_RESULT sendSenderReport		();
    HX_RESULT sendReceiverReport	();
    HX_RESULT sendBye			();
    HX_RESULT writePacket		(IHXBuffer* pBuf);
    
    IHXTCPSocket*			m_pTCPSocket;
    INT8				m_tcpInterleave;
//    friend class RTPBaseTransport;
//    friend class RTPTCPTransport;
};

#endif /* ndef _RTPTRAN_H_ */