diff -r 000000000000 -r 307788aac0a8 rtp/rtpstack/inc/rtpsession.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/rtp/rtpstack/inc/rtpsession.h Tue Feb 02 01:03:15 2010 +0200 @@ -0,0 +1,479 @@ +/* +* Copyright (c) 2004-2005 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + + + + +#ifndef __RTPSESSION_H +#define __RTPSESSION_H + +// INCLUDES +#include +#include +#include "rtputil.h" +#include "rtptimer.h" +#include "rtpsdes.h" +#include "rtpsessiondef.h" + +//Packet +#include "rtppacket.h" +#include "rtppacketext.h" +#include "rtppacketparam.h" + +//Stream +#include "rtpstreamdef.h" +#include "rtptranstream.h" +#include "rtprecvstream.h" +#include "rtpasignuniqueid.h" + +//Comm +#include "rtpcomm.h" +#include "rtpcommdef.h" + + +/** +* class for rtp session. +* +* @lib RtpService.dll +*/ +class CRtpSession : + public CBase, + public MReceivedNotify, + public MTimeOutNotify, + public MSsrcCheckCallback + { + + public: + + enum TStreamType + { + ETxStream = 0, + ERxStream + }; + + enum + { + ECallBack, + ETimeOut + }; + + public: // new functions + static CRtpSession* NewL( const TCreateSessionParams& aParams, + TUint& aPort, + TBool aEnableRtcp, + const TRtcpParams* aRtcpParams, + RSocketServ& aSocketServ, + RConnection& aRConn, + const TRtpId aSessionId, + const CRtpSDES* aSdes, + const TUint32* aProfileRTPTimeRates, + const TBool aStandardRtp, + const RLibrary& aLibrary, + MRtpErrNotify& aErrNotify, + MRtpAsignUniqueID& aAssignUniqueID ); + + ~CRtpSession(); + + TRtpSSRC SSRC() const; + + TInt StartSession(); + + TInt SetRemoteAddress( TInetAddr& aRemoteAddr ); + TInt SetRemoteRtcpAddress( TInetAddr& aRemoteAddr ); + + TInt CreateReceiveStreamL( TRtpId aStreamId, const TRtpPayloadType aPayloadType ); + + TInt CreateTransmitStreamL( TRtpId aStreamId, const TRtpPayloadType aPayloadType, TUint32& aSSRC ); + + TInt CreateTransmitStreamExtL( TRtpId aStreamId, const TRtpPayloadType aPayloadType, const TUint32 aSSRC ); + + void CloseStream( TRtpId aStreamId ); + + void ResetTxStreamStats(); + void ResetRxStreamStats(); + + TInt RegisterRtpObserver( MRtpObserver& aObserver ); + void UnregisterRtpObserver(); + + TInt SetNonRTPDataObserver( MNonRTPDataObserver* aNonRTPDataObserver ); + + TInt SendRtpPacket( TRtpId aTranStreamId, const TRtpSendHeader& aHeaderInfo, + const TDesC8& aPayloadData ); + + TInt SendRtpPacket( TRtpId aTranStreamId, + const TRtpSendHeader& aHeaderInfo, + const TDesC8& aPayloadData, + TRequestStatus& aStatus ); + + TInt SendRtpPacket( const TRtpSendHeader& aHeaderInfo, const TDesC8& aPayloadData ); + + TInt SendRtpPacket( const TRtpSendHeader& aHeaderInfo, const TDesC8& aPayloadData, + TRequestStatus& aStatus ); + + TInt SendRtpPacket( TRtpId aTranStreamId, + TRtpSequence aSequenceNum, + const TRtpSendHeader& aHeaderInfo, + const TDesC8& aPayloadData, + TRequestStatus& aStatus ); + + void SendData( TBool aUseRTPSocket, + const TDesC8& aData, + TRequestStatus& aStatus ); + + void CancelSend(); + + TInt RegisterRtcpObserver( MRtcpObserver& aObserver ); + void UnregisterRtcpObserver(); + TInt SendRtcpByePacketL( TRtpId aTranStreamId, const TDesC8& aReason ); + TInt SendRtcpAppPacketL( TRtpId aTranStreamId, const TRtcpApp& aApp ); + TInt SendRtcpSrPacketL( TRtpId aTranStreamId ); + TInt SendRtcpRrPacketL( TRtpId aRecvStreamId ); + + RSocket* GetRtpSocket(); + RSocket* GetRtcpSocket(); + + TInt GetStreamStatistics( TRtpId aStreamId, TRtpPeerStat& aStat ); + TInt SetRtcpParameters( const TRtcpParams& aRtcpParams ); + + TRtpId GetSessionId(); + + TInt StopRtcpSending(); + TInt ResumeRtcpSending(); + + /** + * Gets the status of automatic RTCP sending. + * @param TBool& aAutoSending - ETrue: RTCP atuo sending is on + * EFalse: RTCP auto sending is off + * @return TInt - KErrNone if successful; KErrNotSupported if RTCP + * disabled; system wide error code otherwise + */ + TInt IsRtcpSendingSuspended( TBool& aAutoSending ); + + public: // from MSsrcCheckCallback + /** + * Checks if a newly received SSRC collides with the SSRC's of the + * existing Tx streams in this session, and reacts appropriately. + * This is SSRC collision handling. + * @param aSSRC a newly received SSRC + */ + TInt CheckRemoteSsrcL( TRtpSSRC& aSSRC ); + TBool CheckRemoteAddr(); + + public: // from MTimeOutNotify + void OnExpiredL( TInt aStatus ); + + public: // from MReceivedNotify + void OnRtpReceivedL(); + void OnRtcpReceivedL(); + void OnReceptionError( TPortType aPort, TInt aError ); + void OnPacketRejected(TPortType aPort); + TBool IsSrtp(); + protected: // construction + CRtpSession( const TRtpId aSessionId, + const TUint32* aProfileRTPTimeRates, + const TBool aStandardRtp, + MRtpErrNotify& aErrNotify, + const CRtpSDES* aSdesInfo, + MRtpAsignUniqueID& aAssignUniqueID ); + + void ConstructL( const TCreateSessionParams& aParams, + TUint& aPort, + TBool aEnableRtcp, + const TRtcpParams* aRtcpParams, + RSocketServ& aSocketServ, + RConnection& aRConn, + const RLibrary& aLibrary, + MRtpErrNotify& aErrNotify ); + void FindRtpRxStreamSSRC(TRtpSSRC& aSSRC); + TInt FindStream( const TRtpId aMagicKey, TUint& aStreamAddress ); + TInt IssueRtpRecv(); + virtual void SendSRTCPReportL(TRtpSSRC aSSRC); + void AverageRtcpSize( TUint aRtcpReportSize ); + TInt IssueRtcpRecv(); + + private: + TInt InitialiseRtcp( const TRtcpParams* aParams ); + + + + void ScheduleRtcpSendL(); + void StartReceiveRtcpPacket(); + void StopReceiveRtcpPacket(); + + TBool DoBuildSendRTCPReportIfNotSentL(); + void DoBuildSendRTCPReportL(); + TBool ShouldBuildEmptyRR( CRtpTranStream* aTempTranStream ); + + /** + * Determines the source count and length before an RTCP report is sent + * @param aSourceCount reference to the source count variable to update + * @param aLength reference to the packet length variable to update + * @param aRxActive a list of active/not active streams + * @return None + */ + void DetermineSourceCountAndLength( TInt& aSourceCount, + TInt& aLength, + TBool aRxActive[] ); + + /** + * Determines parameters before an RTCP report with SR (RR) and SDES + * sections is sent. + * @param aTranStream The stream that will send the RTCP report + * @param aStreamParam pointer to the stream parameters + * @param aInitParam pointer to the initialisation parameters + * @param aRxActive a list of active/not active streams + * @return None + */ + void SetParamsForFullRTCPReport( CRtpTranStream* aTranStream, + TRtpPacketStreamParam* aStreamParam, + TRtpPacketIOParam* aInitParam, + TBool aRxActive[] ); + void BuildSendRTCPReportL(); + TInt BuildRTCPReport( CRtpTranStream* tempStream, TInt aLastReport ); + void BuildSrSection( CRtpTranStream* aTempTranStream ); + void BuildRrSection( TInt aNumRcvStreams, + TBool aRxActive[KMaxNumActiveRcvStreams], + TInt aLastReport ); + void BuildEmptyRr( CRtpTranStream* aTempTranStream ); + void BuildSdesSection( CRtpTranStream* aTempTranStream ); + void SendRTCPReport(); + void CreateSDES( TInt aFCNameOnly, TRtpSSRC aSSRC ); + + + /** + * Launches the processing of individual sections of RTCP reports. + * @param extractParam pointer to the stream parameters + * @param aSourceSSRC The synchronisation source value of the sender + * @return Symbian OS error code + */ + TRtpRtcpEnum ProcessOneRTCPReportSectionL( + const TRtpPacketIOParam& aExtractParam, + TRtpSSRC aSourceSSRC ); + /** + * Processes an RTCP report. + * @return An RTP-specific error code + */ + TRtpRtcpEnum ProcessRTCPReportL(); + + /** + * Processes the SR section of an RTCP report. + * @return An RTP-specific error code + */ + TRtpRtcpEnum ProcessSRSectionL( TInt aSourceCount ); + + /** + * Processes the RR section of an RTCP report. + * @return An RTP-specific error code + */ + TRtpRtcpEnum ProcessRRSectionL( TInt aSourceCount ); + + /** + * Processes the SDES section of an RTCP report. + * @return An RTP-specific error code + */ + TRtpRtcpEnum ProcessSDESSectionL( TRtpSSRC aSourceSSRC ); + + /** + * Processes the BYE section of an RTCP report. + * @return An RTP-specific error code + */ + TRtpRtcpEnum ProcessBYESectionL(); + + /** + * Processes the APP section of an RTCP report. + * @return An RTP-specific error code + */ + TRtpRtcpEnum ProcessAPPSectionL( TInt aTotalPacketLen, TInt aSubType ); + + /** + * Processes the data contained in an SDES section. + * @return An RTP-specific error code + */ + TRtpRtcpEnum ProcessSDESDataL( TRtpPacketStreamParam& aStreamParam, + TRtpPacketIOParam& aExtractParam, + TRtpSSRC aSourceSSRC ); + + /** + * Gets the SDES values from the data contained in an SDES section. + * Either aRecvStream or aSourceSdes is always NULL. + * @param aTargetSdes the SDES in which the data will be stored + * @param aRecvStream the stream that contains the SDES + * @param aSourceSdes the SDES in which the data resides + * @return KErrNone if successful, a system-wide error code otherwise + */ + TInt GetSDESFromSDESData( TRtpSdesParams* aTargetSdes, + const CRtpRecvStream* aRecvStream, + CRtpSDES* aSourceSdes ); + + /** + * Logs the SDES data from the data contained in an SDES section. + * @param aStreamParam stream parameters + * @param aRecvStream the receiving stream + * @param aSdes the new SDES + * @param aSdesSession indicates whether the SDES was assigned to the + * session + */ +#ifdef _DEBUG + void LogSDESData( const TRtpPacketStreamParam& aStreamParam, + const CRtpRecvStream* aRecvStream, + const CRtpSDES* aSdes, + const TBool aSdesSession ); +#endif + TRtpSSRC GetUniqueSSRC(); + TRtpSSRC GenerateSSRC(); + TInt AddStream( const TStream aArrayID, TStreamType aStreamType ); + + TInt FindStream( const TRtpId aMagicKey, TUint& aStreamAddress, + TStreamType& aStreamType ); + TInt RemoveStream( const TRtpId aMagicKey, TStreamType& aStreamType ); + void RemoveAllStreams(); + TInt MatchSSRCToStream( TUint& aRcvStreamAddress, TRtpSSRC aSSRC, + TStreamType& aStreamType ); + TInt FindRtpRxStreamL(); + TInt AssignRtpRxStreamL(); + + TInt StreamSendBYEPacket(); + TInt StreamSendAPPPacket(); + TBool FindStreamForSSRC( TRtpSSRC aSSRC ); + /** + * Finds if a send stream is already using the given SSRC + * @param aSSRC the synchronisation source value + * @param a pointer to a stream pointer. If a Tx stream is found for + * the specified SSRC, the stream pointer contains the address of the + * Tx stream when this function returns. + */ + TBool FindTxStreamForSSRC( TRtpSSRC aSSRC, + CRtpTranStream** streamPointerPointer ); + + TBool RcvStreamActive( TInt aIndex ); + TBool AnyRcvStreamReceivedRtpPacket(); + TBool RcvStreamReceivedRtpPacket( TInt aIndex ); + CRtpRecvStream* GetRcvStreamByIndex( TInt aIndex ); + + void RedistributeBandwidth(); + + CRtpSDES* DoAddSdesToArrayL( TRtpPacketIOParam* aExtractParam ); + TBool AddSdesToArrayL( TUint& aSdesAddress, TRtpPacketIOParam* extractParam ); + + /** + * Compares the specified SDES values with the ones in the parameters + * and updates the SDES where the values differ + * @param aTempSdes the target SDES + * @param aExtractParam the parameters to compare with + * @param aUpdateCName indicates whether to include the CName + * @return ETrue if the SDES was updated + */ + TBool CompareAndUpdateSdes( CRtpSDES* aTempSdes, + TRtpPacketIOParam* aExtractParam, + TBool aUpdateCName ); + TInt RemoveSdesFromArray( TRtpSSRC aSSRC ); + + void NextRtcpInterval(); + + void DeallocateMemoryForSdes( TRtpPacketIOParam* aParam ); + + // Methods for getting random numbers + TInt Random(); + TReal Random64(); + void SendRTCPByewithBanedSSRCL(); + TBool CheckifBanded(); + void CreateNewRecvStreamL(); + + + private: + TBool iStandardRtp; + TRtpId iSessionId; // session ID value + + + TInetAddr iRemoteAddr[KMaxPorts]; // store here remote addresses + TBool iRemoteAddrSet; + + // default values for this session when no transmit stream has been created. + TRtpSSRC iDefaultSSRC; // default SSRC value + + const CRtpSDES* iLocalSdes; // iManager->GetSdes(); + TRtpSdesParams* iNewSdes; // Sdes to send to observer + TInt iSendSdesCounter; // keeps track of SDES packets sent + + protected: + CRtpPacket* iPktSnd; + CRtpPacket* iPktRcv; + TPtr8 iRtpRecvBuf; // receive buf of iPktRtpRcv; + TPtr8 iRtcpRecvBuf; // receive buf of iPktRtcpRcv; + CRtpComm* iCommNet; + MRtpPacketExt* iPktExtSnd; + TBool iIsSrtp; + TBool iRtcpEnabled; + CRtpTimer* iSndRtcpTimer; // timer for period sending RTCP packets + + // packets allocated for reporting, sending, receiving + CRtpPacket* iPktRtcpSnd; + CRtpPacket* iPktRtcpRcv; + + + + + // packets allocated for extended rtp packet + + MRtpPacketExt* iPktExtRcv; + + // Flags + TBool iFirstRTCPSent; // flag that indicates if the first RTCP Packet has been sent + TBool iFPortsInit; // indicates if the local port has been initialized + + TUint16 iNumOfTxStreams; // total number of send streams + TUint16 iNumOfRxStreams; // total number of receive streams + CArrayFixFlat* iStreamTxArray; //array to keep Transmit stream objects + CArrayFixFlat* iStreamRxArray; //array to keep Receive stream objects + CArrayPtrFlat* iSdesArray; //array to keep remote participants SDES object + RArray iRxSSRCArray; //array to keep ReceiveStreamSSRC Array + + const TUint32* iProfileRTPTimeRates; + TReal iAverageRtcpSize; // average RTCP report size updated everytime a RTCP report is send or/and received + TUint iBandWidth; // session bandwidth + TReal iFraction; // fraction of the session bandwidth to be used for RTCP report + TUint iRtcpTimeInterval; // RTCP report interval (milliseconds) + TUint iTotalParticipantsSession;// keeps track of total participants in session + + MRtpObserver* iRtpObserver; + MRtcpObserver* iRtcpObserver; + MNonRTPDataObserver* iNonRTPDataObserver; + MRtpErrNotify& iErrNotify; + MRtpAsignUniqueID& iAssignUniqueID; + + + TBool iSessionStarted; + TInt iSSRCJumps; + TInt iRtcpErrors; + + TBool iRtcpSendingSuspended; + TInt64 iSeed; + + private: + #ifdef EUNIT_TESTING + friend class UT_CRtpAPI; + friend class UT_CRtpSession; + friend class UT_CRtpSessionSrtp; + #endif + #if defined( _DEBUG ) && defined( RTP_UNIT_TEST ) + friend class CRtpUtRtpSession; + #endif + }; + +#endif // __RTPSESSION_H + +// End of File