// 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:

// Header for class specific to rtp unit tests

// 

//

/**

 @file

 @internalComponent

*/

#if (!defined T_RTPCORESERVER_H__)

#define T_RTPCORESERVER_H__

#include <testexecuteserverbase.h>

#if (!defined __DATA_CAGING__)

IMPORT_C TInt NewServer();

#endif

#include "rtpcontroller.h"

#include "rtcppacket.h"

#include "rtppacket.h"

class CTRtpCoreStep;

class CTRtpCoreServer : public CTestServer

	{

public:

	static CTRtpCoreServer* NewL();

	virtual CTestStep* CreateTestStep(const TDesC& aStepName);

	~CTRtpCoreServer();

	// Member functions used by test steps

	/*

	static void StopScheduler(CTrtpServer* aPtr, const TRtpEvent& aEvent);

	*/

	static TBool CompareRtpHeadersFromBuf(TDesC8& buf1,TDesC8& buf2);

	static TBool CompareRtpHeaderWithBuf(TRtpFixedHdrMemLayout& aHeader,TDesC8& aBuf);

	static TBool CompareRtcpHeadersFromBuf(TDesC8& buf1,TDesC8& buf2);

	static TBool CompareRtcpHeaderWithBuf(TRtcpFixedHdrMemLayout& aHeader,TDesC8& aBuf);

	// Members used by the steps

	TBool iOom;

	CTRtpCoreStep* iCurrentStep;

	TBool iStopping;

	TInt iStopCount;

	RConnection iConnection;

	RSubConnection iSubConnection;

	// generic socket, e..g send

	RSocket iSocket;

	// for connected/bind socket use cases

	RSocket iRtpSocket;

	RSocket iRtcpSocket;

	TBool iUsingConnectedSocket;

	CActiveScheduler* iScheduler;

	RSocketServ iSocketServer;

	CRtpControllerBase* iController;

	CRtpControllerBase* iSendController;

 private:

	CTRtpCoreServer();

	};

class CWaiter : public CBase, public MRtpDataObserver

	{

 public:

	static CWaiter* NewLC(CTRtpCoreServer* aServer);

	~CWaiter();

	void DataAvailable(TInt aErrorCode);

 private:

	CWaiter(CTRtpCoreServer* aServer) : iServer(aServer) 

			{

			};

	CTRtpCoreServer* iServer;

 public:

    TRequestStatus iStatus;

	};

struct TRtpFixedHeader

  	{

  	TUint8 iVersion:2;		// protocol version

  	TUint8 iP:1;			// padding flag

  	TUint8 iX:1;			// header extension flag

  	TUint8 iCC:4;			// CSRC count

  	TUint8 iM:1;			// marker bit

  	TUint8 iPT:7;			// payload type

  	TUint16	iSequenceNo;	// sequence number

  	TUint32	iTimeStamp;		// timestamp

  	TUint32	iSSRC;			// synchronization source

  	//RArray<TUint32> iCSRC; // optional CSRC list

  	TRtpFixedHeader();

  	};

inline TRtpFixedHeader::TRtpFixedHeader()

  	{

  	iVersion = KRtpVersion2;	// protocol version = 2

  	iP = 0;						// padding flag

  	iX = 0;						// header extension flag

  	iCC = 0;					// CSRC count

  	iM = 0;						// marker bit

  	iPT = 0;					// payload type

  	iSequenceNo = 0;			// sequence number

  	iTimeStamp = 0;				// timestamp

  	iSSRC = 0;					// synchronization source

  	}

class CRtpFixedHeader

   	{

   public:

   	CRtpFixedHeader(TDes8& packet);

   	CRtpFixedHeader();

   	~CRtpFixedHeader();

   	void SetVersion(TUint aVersion);

   	void SetCSRCCount(TUint aCC);

   	void SetSequenceNumber(TUint16 aNo);

   	void SetSSRC(TUint32 aSSRC);

   	void SetPadding(TBool aPadding);

   	void SetExtension(TBool aExtension);

   	void SetTimeStamp(TUint32 aTime);

   	TUint32 SSRC();

   	TUint8 CC();

   	TBool IsMarker();

   	TBool IsPadding();

   	TBool IsExtension();

   	TUint8 PayloadType();

   	TUint8 Version();

   	TUint16 SequenceNumber();

   	TUint32 TimeStamp();

   	TUint32 CSRCs(TInt aIndex);

private:

   	TRtpFixedHeader iHeader;

   	};

// RTCP //

// Reception report block

struct TRtcpRRBlock

	{

	TUint32 iSSRC;	// data source being reported

    TUint iFractionLost:8;	// fraction lost since last SR/RR

	TInt iCumulLost:24;	// cumul. no. pkts lost (signed!)

	TUint32 iExtendedLastSeq;	// extended last seq. no. received

    TUint32 iJitter;	// interarrival jitter

    TUint32 iLastSR;	// last SR packet from this source

    TUint32 iDSLR;	// delay since last SR packet

	};

// SDES item

struct TRtcpSDESItem

	{

	TUint8 iType;		// type of item (rtcp_sdes_type_t)

	TUint8 iLength;		// length of item (in octets)

	HBufC8* iData;		// text, not null-terminated 

   };

//One RTCP packet

struct TRtcpPacketStruct

	{

	struct

		{

		// common part

		// protocol version

		TUint iVersion:2;

		// padding flag

		TUint iPadding:1;

		// varies by packet type

		TUint iCount:5;

		// RTCP packet type

		TUint iPacketType:8;

		// pkt len in words, w/o this word

		TUint16 iLength;

		} common;

	union 

		{

		// sender report (SR)

		struct 

			{

			TUint32 iSSRC;     // sender generating this report

			TUint32 iNtpSeconds;  // NTP timestamp

			TUint32 iNtpFraction;

			TUint32 iRtpTimeStamp;   // RTP timestamp

			TUint32 iPacketsSent;    // packets sent

			TUint32 iOctetsSent;    // octets sent

            TRtcpRRBlock iRR[1];  // variable-length list

			} sr;

		// reception report (RR)

		struct 

			{

			TUint32 iSSRC;		// receiver generating this report

			TRtcpRRBlock iRR[1];	// variable-length list

			} rr;

		// source description (SDES)

		struct

			{

			TUint32 iSRC;			// first SSRC/CSRC

			TRtcpSDESItem iItem[1];	// list of SDES items

			} sdes;

		// BYE

		struct 

			{

			TUint32 iSRC[1];   // list of sources

               /* can't express trailing text for reason */

           } bye;

		// App

		struct

			{

			TUint32 iSRC;

			HBufC8* iAppName;

			HBufC8* iAppData;

			} app;

       } specific;

   };

class CRtcpPacketTest

   	{

   public:

   	CRtcpPacketTest(TDes8& aPacket);

   	//CRtcpRRPacket();

   	~CRtcpPacketTest();

	void Init(TDes8& aPacket);

	TBool operator==(CRtcpPacketTest& aPacket);

	TBool operator!=(CRtcpPacketTest& aPacket);

   	void SetVersion(TUint aVersion);

	void SetPadding(TBool aPadding);

   	void SetCount(TUint8 aCount);

   	void SetPacketType(TRtcpPacketType aPacketType);

	void SetLength(TUint16 aLength);

	TUint Version();

	TBool IsPadding();

   	TUint8 Count();

	TRtcpPacketType PacketType();

   	TUint16 Length();

protected:

   	TRtcpPacketStruct iPacket;

   	};

class CRtcpRRPacketTest : public CRtcpPacketTest

   	{

   public:

   	CRtcpRRPacketTest(TDes8& aPacket);

   	~CRtcpRRPacketTest();

	TBool operator==(CRtcpRRPacketTest& aPacket);

	TBool operator!=(CRtcpRRPacketTest& aPacket);

	void SetSenderSSRC(TUint32 aSSRC);

	void SetReportSSRC(TUint32 aSSRC);

	void SetFraction(TUint8 aFraction);

	void SetLost(TUint aLost);

	void SetHighestSequence(TUint32 aSeq);

   	void SetJitter(TUint32 aJitter);

	void SetLastSR(TUint32 aLastSR);

   	void SetDSLR(TUint32 aDSLR);

   	TUint32 SenderSSRC();

	TUint32 ReportSSRC();

   	TUint8 Fraction();

	TUint Lost();

	TUint32 HighestSequence();

	TUint32 Jitter();

	TUint32 LastSR();

   	TUint32 DSLR();

   	};

class CRtcpSRPacketTest : public CRtcpPacketTest

   	{

   public:

   	CRtcpSRPacketTest(TDes8& aPacket);

   	~CRtcpSRPacketTest();

	TBool operator==(CRtcpSRPacketTest& aPacket);

	TBool operator!=(CRtcpSRPacketTest& aPacket);

	void SetSenderSSRC(TUint32 aSSRC);

	void SetNtpMsb(TUint32 aNtpMsb);

	void SetNtpLsb(TUint32 aNtpLsb);

	void SetRtpTimeStamp(TUint32 aRtpTs);

	void SetPacketCount(TUint32 aPacketCount);

	void SetOctetCount(TUint32 aOctetCount);

	void SetReportSSRC(TUint32 aSSRC);

	void SetFraction(TUint8 aFraction);

	void SetLost(TUint aLost);

	void SetHighestSequence(TUint32 aSeq);

   	void SetJitter(TUint32 aJitter);

	void SetLastSR(TUint32 aLastSR);

   	void SetDSLR(TUint32 aDSLR);

   	TUint32 SenderSSRC();

	TUint32 NtpMsb();

	TUint32 NtpLsb();

	TUint32 RtpTimeStamp();

	TUint32 PacketCount();

	TUint32 OctetCount();

	TUint32 ReportSSRC();

   	TUint8 Fraction();

	TUint Lost();

	TUint32 HighestSequence();

	TUint32 Jitter();

	TUint32 LastSR();

   	TUint32 DSLR();

   	};

class CRtcpByePacketTest : public CRtcpPacketTest

   	{

   public:

   	CRtcpByePacketTest(TDes8& aPacket, TBool aIncreaseOffset = ETrue);

   	~CRtcpByePacketTest();

	TBool operator==(CRtcpByePacketTest& aPacket);

	TBool operator!=(CRtcpByePacketTest& aPacket);

	void SetSSRC(TUint32 aSSRC);

	void SetReasonTxt(TDesC8 aReason);

	TInt ReadSROrRRAndSDESAndIncOffset(const TUint8** aPtr);

   	TUint32 SSRC();

	TDesC8 ReasonTxt();

	TInt iOffset;  

   	};

class CRtcpAppPacketTest : public CRtcpPacketTest

   	{

   public:

	static CRtcpAppPacketTest* NewL(TDes8& aPacket);

	CRtcpAppPacketTest(TDes8& aPacket);

   	~CRtcpAppPacketTest();

	TBool operator==(CRtcpAppPacketTest& aPacket);

	TBool operator!=(CRtcpAppPacketTest& aPacket);

	void SetSSRC(TUint32 aSSRC);

	void SetAppData(const TDesC8& aAppData);

	void SetAppName(const TDesC8& aAppName);

   	TUint32 SSRC();

	const TDesC8& AppData();

	const TDesC8& AppName();

   private :

 void ConstructL(TDes8& aPacket);

   	};

class CItem : public CBase

	{

public:

	static CItem* NewL( const TDesC8& aItem, TInt aType );

	static TInt FlatCompare(const CItem& aItemOne, const CItem& aItemTwo ); //Assume that given CItem are a flat-data structures, compare 

						//them byte by byte, and if all bytes are exactly same

						//return true

private:

	void ConstructL( const TDesC8& aItem );

	CItem( TUint8 aType );

	~CItem();

	TBool DoFlatCompare( const CItem& aItem ) const;

private:

	TUint8 iType;

	HBufC8* iData;

	};

class CRtcpSDESPacketTest : public CRtcpPacketTest

   	{

public:

	static CRtcpSDESPacketTest* NewL(TDes8& aPacket);

	CRtcpSDESPacketTest(TDes8& aPacket); //Should really be private

   	~CRtcpSDESPacketTest();

	TBool operator==(CRtcpSDESPacketTest& aPacket);

	TBool operator!=(CRtcpSDESPacketTest& aPacket);

	void SetSSRC(TUint32 aSSRC);

	void SetType(TSDESType aType);

	void SetData(const TDesC8& aData);

	TInt SROrRRLength() const;

	TUint32 SSRC();

	TSDESType Type();

	const TDesC8& Data();

	CItem* NextL();

	CItem* First();

private:   

   void ConstructL(TDes8& aPacket);

private:

	TInt iOffset;   

	TInt iPktSize; //Assuming that there is no trailing BYE???

	TInt iItemCount; 

	CItem* iFirstItem;

	const TUint8* iStartOfPkt;

	TInt iCurrentOffset;

  	};

class RSdesItemManager

	{

public:

	RSdesItemManager();

	~RSdesItemManager();

	TInt Open();

	void Close();

	TInt StoreL( const TDesC8& aItem, TInt aItemType );

	TInt SegregateItemsL();

	TInt CompareSentAndReceivedValues();

	void SetRecvBuffer( CRtcpSDESPacketTest * aSdesPkt ) { iSdesPkt = aSdesPkt; }

private:

	RPointerArray<CItem> iArray;//Sent items list

	TInt iCurrentItem;

	RPointerArray<CItem> iSegregatedItemsArray;//received items list

	TInt iSegregatedItemsArrayID;

	CRtcpSDESPacketTest * iSdesPkt;

	};

#endif