diff -r 000000000000 -r 1bce908db942 multimediacommscontroller/mmccrtpwrapper/inc/rtpmanager.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/multimediacommscontroller/mmccrtpwrapper/inc/rtpmanager.h Tue Feb 02 01:04:58 2010 +0200 @@ -0,0 +1,728 @@ +// Copyright (c) 2007-2009 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: +// This file provides the information required for building the whole of a rtpwrapper. +// +// + +/** + @file +*/ + +#ifndef __RTP_MNGER_H__ +#define __RTP_MNGER_H__ + +#include +#include +#include + +#include "rtpapi.h" +#include + +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#endif + +#include +#include + + +const TInt KDefaultStartRtpAddress = 8000; +const TInt KDefaultMaxRxSz = 1250; +const TUint KRtpDefaultBandWidth = 64000; + +// Minimum bandwidth in bps +const TUint KRtpMinimumBandWidth = 8000; + +// RTCP minimum interval (ms) (default is 5 seconds) +const TUint KRtpDefaultRtcpInterval = 5000; +//Unspecified PayloadType +const TInt KRtpPayloadTypeUnspecified = -1; + +const TInt KSrtpMaxAuthTagLength = 20; +const TInt KSrtpMaxMKILen = 10; + +class CRtpManager; + +/* Node representing a pending RTP request. + * When an Asynchronous send is requested the details are stored in this node + * and then put in to a list. The head is scheduled for transmission + */ +class TRtpSendReqNode + { + public: + TSglQueLink iLink; + RRtpSendPacket iPktToSend; + TRequestStatus* iStatus; + }; + +/* Note this 'T' Class. It donot own the Resources. + * It is the responsibility of the creator to make sure + * the resources are properly freed. By putting the resources + * in this class the ownership is not transfered */ +NONSHARABLE_CLASS(CRtpSessionInfo) : public CBase, public MPrePostProcessingCallback + { + public: + TUint32 iKey; + TInt iPortNumber; /* The RTP Port number used by this Session */ + + #ifndef SYMBIAN_ENABLE_SPLIT_HEADERS + RRtpSession iRtpSession; /* Session */ + #else + RRtpSession_Internal iRtpSession; /* Session */ + #endif + + CSRTPSession* iSRTPSession; + TInt iPayloadType; /* The Payload type for this SendStream */ + RRtpSendSource iRtpSendSource; + CRtpManager* iRtpManager; /* To find our way back from callbacks */ + MRtpObserver *iRtpObserver; + TBool iRtcpEnabled; + MRtcpObserver *iRtcpObserver; + TBool iFirstPacketSent; + + /* A session can have only one Payload type */ + TUint32 iSamplingRate; + MNonRTPDataObserver *iNonRtpDataObserver; + TInetAddr iRemoteAddress; + TInetAddr iRemoteRTCPAddress; + /* TODO CleanThisUp!!! List of pending requests */ + TSglQue *iPendingReqQue; + + TInt PreRtpProcessing(TDes8& aRTPPacket); + void PostRtpProcessing(TDes8& aRTPPacket); + TInt PreRtcpProcessing(TDes8& aRTPPacket); + void PostRtcpProcessing(TDes8& aRTPPacket); + + static CRtpSessionInfo* NewL(); + void ConstructL(); + + private: + CRtpSessionInfo():iFirstPacketSent(EFalse),iPayloadType(KRtpPayloadTypeUnspecified) + { + } + + }; + +/* Stores the Information regarding a Particular RTP recv Stream + * belonging to a session */ +class TRtpStreamInfo + { +public: + enum TStreamInfoState + { + /* Pre-Created->created before any new source was + * detected. When a new Source is finally detected + * this ID will be used. The state will change to + * eStreamReadyToUse */ + eStreamPreCreated, + /* Post Created stream: A new source was detected + * but there were no pre created stream to assign this + * stream to. When the appilcation calls CreateReceiveStream + * then this stream will be picked up and its ID will be + * returned( if the payload type matches). */ + eStreamPostCreated, + /* ID is given to the Application and the RRtpReceiveSource + * is valid */ + eStreamReadyToUse + }; + + TUint32 iKey; + TUint32 iSessionKey; /* The Session to which this Stream belongs to */ + TInt iPayloadType; + TBool iIsRecvStream; + TStreamInfoState iState; + RRtpReceiveSource iRecvSource; + CRtpManager* iRtpManager; /* To find our way back from callbacks */ + }; + +/* This class ByPasses all the function calls to Symbian RTP Stack */ +class CRtpManager: public CBase + { + public: // Constructors and destructor + + /** + * Two-phased constructor. + */ + static CRtpManager* NewL( MRtpErrNotify& aErrNotify ); + + /** + * Destructor. + */ + virtual ~CRtpManager(); + + public: + + /** + * Open and initialize the CRtpAPI object. + * @param aSdesInfo - [input] SDES (Source Description) + * of the local participant (CName, Username, etc.) + * @param aRtpPacketDll - [input] Path+file name of RTP packet + * formatting DLL to use; NULL to use standard RTP packet format + * @param aRConnPtr - [input] Network connection to use; + * NULL to use default network connection. + * @return KErrNone if successful; system wide error code otherwise + */ + TInt OpenL( const TRtpSdesParams& aSdesInfo, + const TDesC* aRtpPacketDll, + const RSocketServ* aSocketServPtr, + const RConnection* aConnPtr ); + + /** + * Open and initialize the CRtpAPI object. + * @param aIapId - [input] IAP ID. If -1, no IAP selection dialog + * will pop up. Instead, the default IAP will be used. + * @return KErrNone if successful; system wide error code otherwise + */ + TInt StartConnection( TInt aIapId = -1 ); + + /** + * Open and initialize the CRtpAPI object in asynchronous mode + * @param aStatus - [output] On completion, will contain a status code: + * KErrNone if successful; system wide error code otherwise. + * @param aIapId - [input] IAP ID. If -1, no IAP selection dialog + * will pop up. Instead, the default IAP will be used. + * @return KErrNone if successful; system wide error code otherwise + */ + TInt StartConnection( TRequestStatus& aStatus, + TInt aIapId = -1 ); + + /** + * Cancels asynchoronous start of connection. + * Any open requests will be completed with KErrCancel. + * @return None + */ + void CancelStart(); + + /** + * Close the CRtpAPI object. + * @param None + * @return None + */ + void Close(); + + /** + * Set SDES (Source Description) information of the local participant. + * Participant is defined as an application program and + * only one local participant is allowed. + * @param aSdesInfo - [input] SDES of the local participant + * (CName, Username, etc.). + * @return None + */ + void SetLocalSdes( const TRtpSdesParams& aSdesInfo ); + + /** + * Get the local IP address + * @param None + * @return local ip address. + */ + TInetAddr& GetLocalIPAddressL(); + + /** + * Create a new RTP Session and return the Session ID as well as the + * local port number assigned for RTP. RTP uses an even port number and + * RTCP, if enabled, uses the next higher (odd) port number. + * @param aSessionParams - [input] Session parameters + * @param aPort - [input] Local port number to use for RTP; + * 0 to use default port number + * - [output] port number assigned for RTP + * @param aEnableRtcp - [input] ETrue to enable RTCP; EFalse to disable + * @param aRtcpParams - [input] RTCP parameters to use; + * NULL to use default RTCP parameters + * @return Identifier (ID) of RTP Session created if successful; + * KNullId otherwise + */ + TRtpId CreateSessionL( + const TCreateSessionParams& aSessionParams, + TUint& aPort, + TBool aEnableRtcp, + const TRtcpParams* aRtcpParams ); + /** + * Create a new, secure RTP Session and return the Session ID as well as the + * local port number assigned for RTP. RTP uses an even port number and + * RTCP, if enabled, uses the next higher (odd) port number. + * User is expected to create corresponding SRTP session prior to calling this + * function. + * @param aSessionParams - [input] Session parameters + * @param aPort - [input] Local port number to use for RTP; + * 0 to use default port number + * - [output] port number assigned for RTP + * @param aEnableRtcp - [input] ETrue to enable RTCP; EFalse to disable + * @param aRtcpParams - [input] RTCP parameters to use; + * NULL to use default RTCP parameters + * @param aSession - [input] SRTP session to be used by this RTP session. + * @return Identifier (ID) of RTP Session created if successful; + * KNullId otherwise + */ + + TRtpId CreateSessionL( + const TCreateSessionParams& aSessionParams, + TUint& aPort, + TBool aEnableRtcp, + const TRtcpParams* aRtcpParams, + CSRTPSession& aSession); + + + /** + * Start an RTP Session. If enabled, RTCP associated with the given + * session is also started. + * @param aSessionId - [input] Session ID + * @return KErrNone if successful; system wide error code otherwise + */ + TInt StartSession( TRtpId aSessionId ); + + /** + * Close an RTP Session. + * @param aSessionId - [input] Session ID + * @return None + */ + void CloseSession( TRtpId aSessionId ); + + /** + * Set remote IP address and port number to RTP Session. + * Port number for RTP must be an even number and the corresponding + * RTCP, if enabled, will be set to use the next higher (odd) port. + * @param aSessionId - [input] RTP Session ID + * @param aRemoteAddr - [input] Remote IP address & port number for RTP + * @return KErrNone if successful; system wide error code otherwise + */ + TInt SetRemoteAddress( TRtpId aSessionId, + const TInetAddr& aRemoteAddr ); + + /** + * Set remote RTCP IP address and port number to RTP Session accoring to RFC 3605 + * i.e. this should be used if RTCP port is different than RTP port + 1 + * @param TRtpId aSessionId - [input] RTP Session ID + * @param TInetAddr& aRemoteAddr - [input] Remote IP address & port + * number for RTP + * @return TInt - KErrNone if successful; KErrNotFound if invalid session id; + * KErrNotSupported if RTCP disabled; system wide error code otherwise + */ + TInt SetRemoteRtcpAddress( TRtpId aSessionId, const TInetAddr& aRemoteRtcpAddr ); + + /** + * Create a Receive stream for an RTP Session and return the stream + * ID which is unique for all RTP Sessions. + * @param aSessionId - [input] RTP Session ID + * @param aParams - [input] Receive stream parameters + * @return Stream ID if successful; KNullId otherwise + */ + TRtpId CreateReceiveStreamL( TRtpId aSessionId, + const TRcvStreamParams& aParams ); + + /** + * Create a Transmit stream for an RTP Session and return the stream + * ID which is unique for all RTP Sessions. SSRC value assigned for the + * very first Transmit stream will be the same as the default SSRC + * value reserved internally by CreateSession function. This function + * is normally used to create a transmit stream where SSRC value is + * randomly generated. + * @param aSessionId - [input] RTP Session ID + * @param aParams - [input] Transmit stream parameters + * @param aSSRC - [output] SSRC value assigned + * @return Stream ID if successful; KNullId otherwise + */ + TRtpId CreateTransmitStreamL( TRtpId aSessionId, + const TTranStreamParams& aParams, + TRtpSSRC& aSSRC ); + + /** + * Create a Transmit stream, with a given SSRC value, for an RTP Session + * and return the stream ID which is unique for all RTP Sessions. This + * extended function is used for a special case where a specific SSRC + * value needs to be associated with the transmit stream being created, + * e.g. for retransmission purpose. + * @param aSessionId - [input] RTP Session ID + * @param aParams - [input] Transmit stream parameters + * @param aSsrc - [input] SSRC value to use + * @return Stream ID if successful; KNullId otherwise + */ + TRtpId CreateTransmitStreamExtL( TRtpId aSessionId, + const TTranStreamParams& aParams, + const TRtpSSRC aSSRC ); + + /** + * Close a Transmit or Receive stream. + * @param TRtpId aStreamId - [input] ID of stream to close + * @return None + */ + void CloseStream( TRtpId aStreamId ); + + /** + * Register a callback object for receiving RTP data packets from an RTP + * Session. Only one receiver callback object is allowed to be + * registered for one Session. + * MRtpObserver::RtpPacketReceived function from aRtpObserver object is + * called when an RTP data packet is received. + * @param aSessionId - [input] RTP Session ID + * @param aRtpObserver - [input] Callback object to receive RTP packets + * @return KErrNone if successful; system wide error code otherwise + */ + TInt RegisterRtpObserver( TRtpId aSessionId, + MRtpObserver& aRtpObserver ); + + /** + * Unregister RTP observer callback object associated with an RTP + * session. + * @param aSessionId - [input] RTP Session ID + * @return None + */ + void UnregisterRtpObserver( TRtpId aSessionId ); + + /** + * Sets/resets the observer for the non-RTP data. + * Only one receiver callback object is allowed to be + * registered for one Session. + * MNonRTPDataObserver::NonRTPDataReceived or + * MNonRTPDataObserver::NonRTCPDataReceived from + * aNonRTPDataObserver object is + * called when a non-RTP data packet is received. + * @param aNonRTPDataObserver an observer, 0-pointer resets the observer + * @return KErrNotFound if non-existing session-ID provided, system-wide error code otherwise. KErrNone if successfull. + */ + TInt SetNonRTPDataObserver( TRtpId aSessionId, + MNonRTPDataObserver* aNonRTPDataObserver ); + + /** + * Send an RTP data packet in a Transmit stream synchronously. + * @param aTranStreamId - [input] ID of Transmit stream + * @param aHeaderInfo - [input] Header information of RTP data packet + * @param aPayloadData - [input] Payload data of RTP data packet + * @return KErrNone if successful; system wide error code otherwise + */ + TInt SendRtpPacket( TRtpId aTranStreamId, + const TRtpSendHeader& aHeaderInfo, + const TDesC8& aPayloadData ); + + /** + * Send an RTP data packet in a Transmit stream asynchronously. + * @param TRtpId aTranStreamId - [input] ID of Transmit stream + * @param aHeaderInfo - [input] Header information + * of RTP data packet to send + * @param aPayloadData - [input] Payload data of RTP data packet to send + * @param aStatus - [output] On completion, will contain a status code: + * KErrNone if successful; system wide error code otherwise + * @return KErrNone if successful; system wide error code otherwise + */ + TInt SendRtpPacket( TRtpId aTranStreamId, + const TRtpSendHeader& aHeaderInfo, + const TDesC8& aPayloadData, + TRequestStatus& aStatus ); + + /** + * Send an RTP data packet asynchronously, with a given sequence number, + * in a Transmit stream mainly for retransmission purpose. + * @param aTranStreamId - [input] ID of Transmit stream + * @param aSequenceNum - [input] Sequence number to use + * @param aHeaderInfo - [input] Header information of RTP data packet + * @param aPayloadData - [input] Payload data of RTP data packet to send + * @param aStatus - [output] On completion, will contain a status code: + * KErrNone if successful; system wide error code otherwise + * @return KErrNone if successful; system wide error code otherwise + */ + TInt SendRtpPacket( TRtpId aTranStreamId, + TRtpSequence aSequenceNum, + const TRtpSendHeader& aHeaderInfo, + const TDesC8& aPayloadData, + TRequestStatus& aStatus ); + + + /** + * Send a non-RTP (control) data packet asynchronously + * @param aSessionId - [input] RTP Session ID + * @param aUseRTPSocket - [input] use RTP/RTCP socket + * @param aData - [input] non-RTP data packet to send + * @param aStatus - [output] On completion, will contain a status code: + * KErrNone if successful; system wide error code otherwise + * @return KErrNone if successful; system wide error code otherwise + */ + void SendDataL( TRtpId aSessionId, + TBool aUseRTPSocket, + const TDesC8& aData, + TRequestStatus& aStatus ); + + /** + * Cancel an outstanding SendRtpPacket() operation. + * @param TRtpId aSessionId - [input] RTP Session ID + * @return None + */ + void CancelSend( TRtpId aSessionId ); + + /** + * Register a callback object for receiving RTCP packets associated with + * a given RTP Session. Only one observer callback object is allowed to + * be registered. One of aRtcpObserver object's callback functions is + * called when an RTCP packet of that type is received. + * @param aSessionId - [input] RTP Session ID + * @param aObserver - [input] Callback object to receive RTCP packets + * @return KErrNone if successful; system wide error code otherwise. + */ + TInt RegisterRtcpObserver( TRtpId aSessionId, + MRtcpObserver& aRtcpObserver ); + + /** + * Unregister RTCP observer callback object associated with an RTP + * session. + * @param aSessionId - [input] RTP Session ID + * @return None + */ + void UnregisterRtcpObserver( TRtpId aSessionId ); + + /** + * Send an RTCP BYE packet for a Transmit stream. + * @param aTranStreamId - [input] Transmit stream ID + * @param aReason - [input] Reason for leaving + * @return KErrNone if successful; system wide error code otherwise + */ + TInt SendRtcpByePacket( TRtpId aTranStreamId, + const TDesC8& aReason ); + + /** + * Send an RTCP APP packet for a Transmit stream. + * @param TRtpId aTranStreamId - [input] Transmit stream ID + * @param TRtcpApp aApp - [input] APP packet to send + * @return KErrNone if successful; system wide error code otherwise + */ + TInt SendRtcpAppPacket( TRtpId aTranStreamId, + const TRtcpApp& aApp ); + + /** + * Send an RTCP RR packet for a Reception stream. + * @param TRtpId aRcvStreamId - [input] Reception stream ID + * @return TInt - KErrNone if successful; system wide error code otherwise + */ + TInt SendRtcpRrPacket( TRtpId aRcvStreamId ); + + /** + * Send an RTCP SR packet for a Transmit stream. + * @param TRtpId aTranStreamId - [input] Transmit stream ID + * @return TInt - KErrNone if successful; system wide error code otherwise + */ + TInt SendRtcpSrPacket( TRtpId aTranStreamId ); + + /** + * Suspend RTCP sending on/off, calculations will continue. + * @param TRtpId aSessionId - [input] RTP Session ID + * @param TBool aAutoSending - [input] Auto sending flag. + * ETrue: RTCP sending will be scheduled normally + * EFalse: RTCP sending will be suspended + * @return TInt - KErrNone if successful; KErrNotFound if invalid session id; + * KErrNotSupported if RTCP disabled; system wide error code otherwise + */ + TInt SuspendRtcpSending( TRtpId aSessionId, TBool aAutoSending ); + + /** + * Gets the status of automatic RTCP sending. + * @param TRtpId aSessionId - [input] RTP Session ID + * @param TBool aAutoSending - [output] ETrue: RTCP auto sending is on + * EFalse: RTCP auto sending is off + * @return TInt - KErrNone if successful; KErrNotFound if invalid session id; + * KErrNotSupported if RTCP disabled; system wide error code otherwise + */ + TInt IsRtcpSendingSuspended( TRtpId aSessionId, TBool& aAutoSending ); + + /** + * Get the session ID of a stream, which belongs to that session. + * @param aStreamId - [input] ID of a stream + * @return Identifier (ID) of RTP Session if found; KNullId otherwise + */ + TRtpId GetSessionId( TRtpId aStreamId ); + + /** + * Get address of Socket object used by a given RTP Session + * to send/receive RTP data packets. + * @param aSessionId - [input] RTP Session ID + * @return Address of Socket object used if successful; NULL otherwise + */ + RSocket* GetRtpSocket( TRtpId aSessionId ); + + /** + * Get address of Socket object used by a given RTP Session + * to send/receive RTCP control packets. + * @param aSessionId - [input] RTP Session ID + * @return Address of Socket object used if successful; NULL otherwise + */ + RSocket* GetRtcpSocket( TRtpId aSessionId ); + + /** + * Retrieve statistical information for a stream + * based on the reports from RTCP SR & RR packets. + * @param aStreamId - [input] ID of stream + * @param aStat - [output] Statistical information + * @return KErrNone if successful; system wide error code otherwise + */ + TInt GetStreamStatistics( TRtpId aStreamId, + TRtpPeerStat& aStat ); + + /** + * Get sampling rate setting for a payload type. + * @param aPayloadType - [input] Payload type + * @return Sampling rate in Hz; 0 if payload type setting not found + */ + TUint32 GetSamplingRate( TUint8 aPayloadType ); + + /** + * Set sampling rate for a payload type. + * @param aPayloadType - [input] Payload type + * @param aSamplingRate - [input] Sampling rate in Hz + * @return KErrNone if successful; system wide error code otherwise + */ + TInt SetSamplingRate( TUint8 aPayloadType, + TUint32 aSamplingRate ); + + /** + * Set RTCP parameters for a given RTP Session. + * This function does nothing if RTCP was not enabled previously. + * @param aSessionId - [input] RTP Session ID + * @param aRtcpParams - [input] RTCP parameters to use + * @return KErrNone if successful; system wide error code otherwise + */ + TInt SetRtcpParameters( TRtpId aSessionId, + const TRtcpParams& aRtcpParams ); + + /** + * Synchronous custom command interface for future extensions. + * Input/output data and return value are defined by each custom command + * @param aFunction - [input] Function ID + * @param aInputData1 - [input] Input data #1; NULL if not used + * @param aInputData2 - [input] Input data #2; NULL if not used + * @param aOutputData - [output] Output data; NULL if not used + * @return Defined by the function + */ + TInt CustomCommandSync( TInt aFunction, + const TDesC8& aInputData1, + const TDesC8& aInputData2, + TDes8& aOutputData ); + + /** + * ASynchronous custom command interface for future extensions. + * Input/output data and return value are defined by each custom command + * @param aFunction - [input] Function ID + * @param aInputData1 - [input] Input data #1; NULL if not used + * @param aInputData2 - [input] Input data #2; NULL if not used + * @param aOutputData - [output] Output data; NULL if not used + * @param aStatus - [output] On completion, will contain a status code: + * KErrNone if successful; system wide error code otherwise + * @return Defined by the function + */ + TInt CustomCommandAsync( TInt aFunction, + const TDesC8& aInputData1, + const TDesC8& aInputData2, + TDes8& aOutputData, + TRequestStatus& aStatus ); + private: + /** + * C++ default constructor. + */ + CRtpManager(); + + /** + * By default Symbian 2nd phase constructor is private. + */ + void ConstructL( MRtpErrNotify& aErrNotify ); + + /* Returns the Session Index or KErrnotFound if Session cannot be found */ + TInt FindSession(TRtpId aSessionId); + + /* Returns the session Index or leaves if not found */ + TInt FindSessionL(TRtpId aSessionId); + + /* Returns the stream Index or KErrnotFound if stream cannot be found */ + TInt FindStream(TRtpId aStreamId); + + /* Returns the stream Index or leaves if not found */ + TInt FindStreamL(TRtpId aStreamId); + + void RegisterEventsOnSessionL(CRtpSessionInfo *aSessionInfo); + void RegisterEventsOnRtpRcvSourceL(RRtpReceiveSource &aRcvSrc, TRtpStreamInfo *apStrmInfo); + void HandleNonRtpDataL(CRtpSessionInfo *apSessionInfo); + void HandleNonRtcpDataL(CRtpSessionInfo *apSessionInfo); + + TInt GetDefaultIapIdL(); + + void MakeACnameL(TDes8 &aCname); + + TInt SendRtpDataFromPendingQueue(CRtpSessionInfo *aSessInfo); + /* Callback Handlers */ + static void RtpSessionLevelCB(CRtpSessionInfo* apSessionInfo, const TRtpEvent& aEvent); + static void RtpStreamLevelCB(TRtpStreamInfo* apSessionInfo, const TRtpEvent& aEvent); + + private: // Data + TBool iOwnsSocketServer; + TBool iOwnsConnection; + TInetAddr iSockAddr; + MRtpErrNotify *iRtpErrNotify; + RSocketServ *iSocketServ; + RConnection *iConnection; + TRtpSdesParams iSdesInfo; //This needs to be looked into. + RPointerArray iRtpSessionArr; + RArray iRtpStreamsArr; + TInt iIapId; + private: + #ifdef __RTPWRAPPER_UNITTEST__ + friend class CRtpManager_GetLocalIPAddress; + friend class CRtpManager_CreateTransmitStream; + friend class CRtpManager_CreateReceiveStream; + friend class CRtpManager_SendData; + friend class CRtpManager_CancelSend; + friend class CRtpManager_SendRtcpByePacket; + friend class CRtpManager_SendRtcpSrPacket; + #endif + #ifdef EUNIT_TESTING + friend class UT_CRtpAPI; + #endif +}; + +/* Loging Macros */ +// Logging + +// Logging +#ifdef _DEBUG + + #ifdef LOG_TO_DEBUGOUT + #include + #define __RTP_LOG_STMT(stmt) stmt + #define LOG_FUNC_ENTRY(text) RDebug::Print(_L("-->>"L##text)); + #define LOG_FUNC_EXIT(text) RDebug::Print(_L("<<--"L##text)); + #define __RTP_LOG(text) RDebug::Print(_L(text)); + #define __RTP_LOG1(text, a) RDebug::Print(_L(text), a); + #define __RTP_LOG2(text, a, b) RDebug::Print(_L(text), a, b); + + #else + #include + #define __RTP_LOG_STMT(stmt) stmt + #define KRtpWrapperLogDir _L("rtp") + #define KRtpWrapperLogFileName _L("rtpcorelog.txt") + #define LOG_FUNC_ENTRY(text) RFileLogger::WriteFormat(KRtpWrapperLogDir, KRtpWrapperLogFileName, EFileLoggingModeAppend,_L("-->>"L##text)); + #define LOG_FUNC_EXIT(text) RFileLogger::WriteFormat(KRtpWrapperLogDir, KRtpWrapperLogFileName, EFileLoggingModeAppend,_L("<<--"L##text)); + #define __RTP_LOG(text) RFileLogger::WriteFormat(KRtpWrapperLogDir, KRtpWrapperLogFileName, EFileLoggingModeAppend, _L(text)); + #define __RTP_LOG1(text, a) RFileLogger::WriteFormat(KRtpWrapperLogDir, KRtpWrapperLogFileName, EFileLoggingModeAppend, _L(text), a); + #define __RTP_LOG2(text, a, b) RFileLogger::WriteFormat(KRtpWrapperLogDir, KRtpWrapperLogFileName, EFileLoggingModeAppend, _L(text), a, b); + #endif + +#else + #ifndef __RTP_LOG_LOG + #include + #define LOG_FUNC_ENTRY(text) + #define LOG_FUNC_EXIT(text) + #define __RTP_LOG_STMT(stmt) + #define __RTP_LOGNoInd(text) + #define __RTP_LOG(text) + #define __RTP_LOG1(text, a) + #define __RTP_LOG2(text, a, b) + #endif + +#endif + + +#endif