1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // class for the rtpwrapper unit test cases

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20 */

    21 

    22 #include <e32math.h>

    23 #include <commdbconnpref.h> 

    24 #include <rtp.h>

    25 #include <rtcp.h>

    26 #include <COMMDB.H> 

    27 #include <srtpsession.h>

    28 #include "rtpheader.h"

    29 #include "rtpmanager.h"

    30 

    31 TInt RtpSessionLinearOrderFunc(const  CRtpSessionInfo& aNew, const CRtpSessionInfo &aArrElem)

    32 	{

    33 	return aNew.iPortNumber - aArrElem.iPortNumber;

    34 	}

    35 

    36 CRtpSessionInfo* CRtpSessionInfo::NewL()

    37 	{

    38 	LOG_FUNC_ENTRY("CRtpSessionInfo::NewL");

    39 	CRtpSessionInfo *self = new(ELeave) CRtpSessionInfo();

    40 	

    41 	CleanupStack::PushL(self);

    42 	self->ConstructL();

    43 	CleanupStack::Pop();

    44 

    45 	LOG_FUNC_EXIT("CRtpSessionInfo::NewL");

    46 	return self;

    47 	}

    48 

    49 void CRtpSessionInfo::ConstructL()

    50 	{

    51 	LOG_FUNC_ENTRY("CRtpSessionInfo::ConstructL");

    52 	}

    53 

    54 /* Creates a CrtpManager object */

    55 CRtpManager* CRtpManager::NewL(MRtpErrNotify& aErrNotify )

    56 	{

    57 	LOG_FUNC_ENTRY("CRtpManager::NewL");

    58     CRtpManager *self = new(ELeave) CRtpManager();

    59 	

    60 	CleanupStack::PushL(self);

    61 	self->ConstructL(aErrNotify);

    62 	CleanupStack::Pop();

    63 

    64 	LOG_FUNC_EXIT("CRtpManager::NewL");

    65 	return self;

    66 	}

    67 

    68 CRtpManager::CRtpManager( )

    69 	{

    70 	LOG_FUNC_ENTRY("CRtpManager::CRtpManager");

    71 	iOwnsConnection   = EFalse;

    72 	iOwnsSocketServer = EFalse;

    73 	LOG_FUNC_EXIT("CRtpManager::CRtpManager");

    74 	}

    75 

    76 CRtpManager::~CRtpManager( )

    77 	{

    78 	LOG_FUNC_ENTRY("CRtpManager::~CRtpManager");

    79 	

    80 	Close();

    81 	

    82 	/* Clean up the Arrays */

    83 	iRtpSessionArr.Close();

    84 	iRtpStreamsArr.Close();

    85 	

    86 	if(iOwnsConnection)

    87 		delete iConnection;

    88 	if(iOwnsSocketServer)

    89 		delete iSocketServ;

    90 	

    91 	LOG_FUNC_EXIT("CRtpManager::~CRtpManager");

    92 	}

    93 

    94 void CRtpManager::ConstructL(MRtpErrNotify& aErrNotify )

    95 	{

    96 	LOG_FUNC_ENTRY("CRtpManager::ConstructL");

    97 	iRtpErrNotify = &aErrNotify;

    98 	LOG_FUNC_EXIT("CRtpManager::ConstructL");

    99 	}

   100 

   101         

   102 TInt CRtpManager::OpenL( const TRtpSdesParams& aSdesInfo,  const TDesC* aRtpPacketDll,

   103                          const RSocketServ* aSocketServPtr, const RConnection* aConnPtr )

   104 	{

   105 	LOG_FUNC_ENTRY("CRtpManager::OpenL");

   106 	/* The current implementation do not support having a different

   107 	 * aRtpPacketDll

   108 	 * So the argument is ignored */

   109 	(void)aRtpPacketDll;

   110 

   111 	if(aSocketServPtr)

   112 		{

   113 		iSocketServ = const_cast<RSocketServ*>(aSocketServPtr);

   114 		}

   115 	else

   116 		{

   117 		iSocketServ = new(ELeave) RSocketServ();

   118 		iOwnsSocketServer = ETrue;

   119 		}

   120 	

   121 	if(aConnPtr)

   122 		{

   123 		iConnection = const_cast<RConnection*>(aConnPtr);

   124 		}

   125 	else

   126 		{

   127 		iConnection = new(ELeave) RConnection();

   128 		iOwnsConnection = ETrue;

   129 		}

   130 	

   131 	iSdesInfo  = aSdesInfo;

   132 

   133 	User::LeaveIfError(iSocketServ->Connect());

   134 	

   135 	User::LeaveIfError(iConnection->Open(*iSocketServ));

   136 	

   137 	LOG_FUNC_EXIT("CRtpManager::OpenL");

   138 	return KErrNone;

   139 	}

   140 

   141 

   142  /**

   143   * Open and initialize the CRtpAPI object.

   144   * @param aIapId - [input] IAP ID. If -1, no IAP selection dialog

   145   *   will pop up. Instead, the default IAP will be used.

   146   * @return KErrNone if successful; system wide error code otherwise

   147  */

   148 TInt CRtpManager::StartConnection( TInt aIapId )

   149 	{

   150 	LOG_FUNC_ENTRY("CRtpManager::StartConnection");

   151 	__RTP_LOG1("IapId = %d",aIapId)

   152 	if(aIapId != -1)

   153 		{

   154 		TCommDbConnPref prefs;

   155 		prefs.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);

   156 		prefs.SetDirection(ECommDbConnectionDirectionOutgoing);

   157 		prefs.SetIapId(aIapId);

   158 		iIapId = aIapId;

   159 		return iConnection->Start(prefs);

   160 		}

   161 	else

   162 		{

   163 		TRAPD(err,iIapId = GetDefaultIapIdL());

   164 		if(KErrNone != err)

   165 			{

   166 			__RTP_LOG1("GetDefaultIapIdL returned  %d",err)

   167 			return err;

   168 			}

   169 		__RTP_LOG1("GetDefaultIapIdL default Iap:  %d",iIapId)

   170 		LOG_FUNC_EXIT("CRtpManager::StartConnection");

   171 		return iConnection->Start();

   172 		}

   173 	}

   174 

   175 TInt CRtpManager::StartConnection( TRequestStatus& aStatus, TInt aIapId)

   176 	{

   177 	LOG_FUNC_ENTRY("CRtpManager::StartConnection-Async");

   178 	__RTP_LOG1("aIapId = %d",aIapId);

   179 

   180 	TCommDbConnPref prefs;

   181 	prefs.SetDialogPreference(ECommDbDialogPrefDoNotPrompt);

   182 	prefs.SetDirection(ECommDbConnectionDirectionOutgoing);

   183 	

   184 	if(aIapId != -1)

   185 		{

   186 		prefs.SetIapId(aIapId);	

   187 		iConnection->Start(prefs, aStatus);

   188 		iIapId = aIapId;

   189 		}

   190 	else

   191 		{

   192 		TRAPD(err,iIapId = GetDefaultIapIdL());

   193 		if(KErrNone != err)

   194 			{

   195 			__RTP_LOG1("GetDefaultIapIdL returned  %d",err)

   196 			return err;

   197 			}

   198 		__RTP_LOG1("GetDefaultIapIdL default Iap:  %d",iIapId)

   199 		prefs.SetIapId(iIapId);

   200 		iConnection->Start(prefs, aStatus);

   201 		}

   202 	LOG_FUNC_EXIT("CRtpManager::StartConnection-Async");

   203 	return KErrNone;

   204 	}

   205 

   206 

   207 /**

   208 * Cancels asynchoronous start of connection.

   209 * Any open requests will be completed with KErrCancel.

   210 * @return None

   211 */

   212 void CRtpManager::CancelStart()

   213 	{

   214 	LOG_FUNC_ENTRY("CRtpManager::CancelStart");

   215 	return;

   216 	}

   217 

   218 

   219 void CRtpManager::Close()

   220 	{

   221 	LOG_FUNC_ENTRY("CRtpManager::Close");

   222 	/* Iterate through the session array and close */

   223 	for(int i=0; i < iRtpSessionArr.Count(); i++)

   224 		{

   225 		__RTP_LOG1("Closing Session Key %u",iRtpSessionArr[i]->iKey);

   226 		iRtpSessionArr[i]->iRtpSession.Close();

   227 		ASSERT(iRtpSessionArr[i]->iPendingReqQue->IsEmpty());

   228 		delete iRtpSessionArr[i]->iPendingReqQue;

   229 		iRtpSessionArr[i]->iPendingReqQue = NULL;

   230 		}

   231 	if(iConnection)

   232 		iConnection->Close();

   233 	

   234 	if(iSocketServ)

   235 		iSocketServ->Close();

   236 	

   237 	LOG_FUNC_EXIT("CRtpManager::Close");

   238 	}

   239 

   240 /**

   241 * Set SDES (Source Description) information of the local participant.

   242 * Participant is defined as an application program and

   243 * only one local participant is allowed.

   244 */

   245  void CRtpManager::SetLocalSdes( const TRtpSdesParams& aSDES)

   246 	{

   247 	/* Should the SDES list be updated again here ? */

   248 	LOG_FUNC_ENTRY("CRtpManager::SetLocalSdes");

   249 	iSdesInfo = aSDES;

   250 	}

   251 

   252 /**

   253 * Get the local IP address

   254 * @param None

   255 * @return local ip address.

   256 */

   257  TInetAddr& CRtpManager::GetLocalIPAddressL()

   258 	{

   259 	LOG_FUNC_ENTRY("CRtpManager::GetLocalIPAddressL");

   260 	/* Open an RSocket and find its address */

   261 	RSocket socket;

   262 	User::LeaveIfError(socket.Open(*iSocketServ, KAfInet, KSockDatagram, KProtocolInetUdp,*iConnection));

   263     

   264 	CleanupClosePushL(socket);

   265 

   266 	TSoInetInterfaceInfo networkInfo;

   267 	TPckg<TSoInetInterfaceInfo> opt(networkInfo);

   268 	User::LeaveIfError(socket.SetOpt(KSoInetEnumInterfaces, KSolInetIfCtrl));

   269 	TSoInetIfQuery query;

   270 	TPckg<TSoInetIfQuery> queryBuf(query);

   271 	TInt res = KErrNone;

   272 	do 

   273 	{

   274 		res = socket.GetOpt(KSoInetNextInterface, KSolInetIfCtrl, opt);

   275 		if (!res && opt().iState == EIfUp)

   276 		{

   277 			query.iName = opt().iName;

   278 			res = socket.GetOpt(KSoInetIfQueryByName, KSolInetIfQuery, queryBuf);

   279 			if (!res && query.iZone[1] == iIapId)

   280 			{

   281 				networkInfo = opt();

   282 				break;

   283 			}

   284 		}

   285 	}

   286 	while (res == KErrNone);

   287     if(res!= KErrNone)

   288     	{

   289     	__RTP_LOG1("Found nothing! ret %d",res)

   290     	/* Didn't find :( */

   291     	User::Leave(res);

   292     	}

   293 	CleanupStack::PopAndDestroy(1);

   294     iSockAddr = networkInfo.iAddress;

   295     LOG_FUNC_EXIT("CRtpManager::GetLocalIPAddressL");

   296 	return iSockAddr;

   297 	}

   298  /**

   299  * Makes a CName that is unique for a given seesion 

   300  */

   301 void CRtpManager::MakeACnameL(TDes8 &aCname)

   302 	{

   303 	/* As of now putting the IP Address. But this is not enough.

   304 	 * multiple sessions should have unique CNAMES 

   305 	 * */

   306 	TBuf<50> ipAddr;

   307 	TInetAddr locAddr = GetLocalIPAddressL();

   308 	locAddr.Output(ipAddr);

   309 	aCname.Format(_L8("%d@"),iRtpSessionArr.Count()+1);

   310 	aCname.Append(ipAddr);

   311 	}

   312 /**

   313 * Create a new RTP Session and return the Session ID as well as the

   314 * local port number assigned for RTP. RTP uses an even port number and

   315 * RTCP, if enabled, uses the next higher (odd) port number.

   316 */

   317  TRtpId CRtpManager::CreateSessionL(const TCreateSessionParams& aSessionParams,

   318                            	                TUint& aPort, TBool aEnableRtcp, const TRtcpParams* aRtcpParams )

   319 	{

   320 	LOG_FUNC_ENTRY("CRtpManager::CreateSessionL");

   321 	__RTP_LOG1("RTCP stat %d",aEnableRtcp)

   322 	TInt localPort;

   323 	/* The RTP Session create takes in the LocalPort.*/

   324 	if(iRtpSessionArr.Count() == 0)

   325 		{

   326 		//In this case start from begining. Start by using the default Even RTP

   327 		//Port.

   328 		localPort = KDefaultStartRtpAddress;

   329 		__RTP_LOG1("LocalPort used %d",localPort)

   330 		}

   331 	else

   332 		{

   333 		/* Pick the next highest port number */

   334 		localPort = iRtpSessionArr[iRtpSessionArr.Count()-1]->iPortNumber + 2;

   335 		__RTP_LOG1("LocalPort used %d",localPort)

   336 		}

   337 	

   338 	//if the user has specified a port then override our selection

   339 	if(aPort)

   340 		{

   341 		localPort = aPort;

   342 		}

   343 	

   344 	//Now use this Port and try opening the RTP Session. If the Session Open

   345 	//fails try opening with the next even port.

   346     //Its much more easier to use the API which takes RSocket directly here. But

   347 	//ths would mean we cannot use the New CFRTP API.

   348 	TInetAddr locAddr(0,localPort);

   349 

   350 	/* Remote address is uninitialized. Unfortunately its required by Symbian

   351 	 * RTP stack. */

   352 	TInetAddr remAddr;

   353 	

   354 	#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

   355 	RRtpSession rtpSession;

   356 	#else

   357 	RRtpSession_Internal rtpSession;

   358 	#endif	

   359  	

   360 	TPtrC8 cnameTptr((TUint8*)"", 0);;

   361 	if(aEnableRtcp)

   362 		{

   363 		TBuf8<50> cnameBuf;

   364 		if(iSdesInfo.iCName == KNullDesC8)

   365 			{

   366 			MakeACnameL(cnameBuf);

   367 			iSdesInfo.iCName.Set(cnameBuf);

   368 			}

   369 		cnameTptr.Set(iSdesInfo.iCName);

   370 		}

   371 	else

   372 		{

   373 		cnameTptr.Set(KNullDesC8);

   374 		}

   375 

   376 	TInt tryCount = 0;

   377 	TInt errOpenl = KErrNone;

   378 

   379 	__RTP_LOG1("Starting Port alloc and OpenL tryCount %d",tryCount);

   380 	__RTP_LOG1("aSessionParams.iSocketBufSize    %d",aSessionParams.iSocketBufSize);	

   381    aPort = locAddr.Port();

   382 

   383     while(tryCount < 5 )

   384 		{

   385     	TRAP(errOpenl,rtpSession.OpenL(*iSocketServ, locAddr, remAddr, aSessionParams.iSocketBufSize, *iConnection, EPriorityNormal, cnameTptr));

   386 		if(errOpenl != KErrNone)

   387 			{

   388 			__RTP_LOG2("OpenL Failed with Error Code %d TryCount %d",errOpenl, tryCount);

   389 			tryCount ++;

   390 			locAddr.SetPort(locAddr.Port()+tryCount+1);

   391 			localPort += tryCount+1;

   392 			}

   393 		else

   394 			{

   395 			break;

   396 			}

   397 		}

   398 

   399     User::LeaveIfError(errOpenl);

   400     

   401 	__RTP_LOG(",rtpSession.OpenL Success!!");

   402 

   403 	TTimeIntervalMicroSeconds32 rtcpInterval;

   404 	if(aEnableRtcp && aRtcpParams)

   405 		{

   406 		rtpSession.SetBandwidth(aRtcpParams->iSessionBWidth);

   407 		__RTP_LOG1(" aRtcpParams->iRtcpTimeOut %d", aRtcpParams->iRtcpTimeOut.Int());

   408 		if(aRtcpParams->iRtcpTimeOut.Int())

   409 		    {

   410 			rtcpInterval = aRtcpParams->iRtcpTimeOut.Int();

   411 		    }

   412 		else

   413 		    {

   414 		    //TODO fix me!

   415 		    //default 500 ms

   416 		    rtcpInterval = 1000000;

   417 		    }

   418         rtpSession.SetRtcpInterval(rtcpInterval);

   419 		}

   420 	else

   421 		{

   422 		__RTP_LOG("Setting default RTCP Properties!!");

   423 		//Default Bandwidth.

   424 		rtpSession.SetBandwidth(KRtpDefaultBandWidth);	

   425 		rtcpInterval = 1000000;

   426 		rtpSession.SetRtcpInterval(rtcpInterval);

   427 		}

   428 	

   429 	//Phew! Now put these in our Array

   430 	CRtpSessionInfo* sessionInfo = CRtpSessionInfo::NewL();

   431 	//Assign a Key for this session.

   432 	sessionInfo->iKey         = Math::Random();

   433 	sessionInfo->iPortNumber  = localPort;

   434 	sessionInfo->iRtpSession  = rtpSession;

   435 	sessionInfo->iRtpManager  = this;

   436 	sessionInfo->iRtcpEnabled = aEnableRtcp;

   437 	sessionInfo->iPendingReqQue = new(ELeave)  TSglQue<TRtpSendReqNode>(_FOFF(TRtpSendReqNode,iLink));

   438 	iRtpSessionArr.InsertInOrder(sessionInfo, TLinearOrder<CRtpSessionInfo>(RtpSessionLinearOrderFunc)); //InsertInOrder(sessionInfo,TLinearOrder<CRtpSessionInfo>(RtpSessionLinearOrderFunc));

   439 

   440 	__RTP_LOG1("Session Created Key %u",sessionInfo->iKey)

   441     //Get back the reference to the object in Array.

   442 	TInt idx = FindSessionL(sessionInfo->iKey);

   443 	

   444     //Register for the Events  

   445 	RegisterEventsOnSessionL(iRtpSessionArr[idx]);

   446 	

   447 	aPort = localPort;

   448 

   449 	//TODO: Fix this in RTP Stack.

   450 	/* Remote Address is uninitialized now. So if RTCP is enabled disable autosend so that

   451 	 * no data is send to incorrect address.

   452 	 */

   453 	if(aEnableRtcp)

   454 		{

   455 		rtpSession.SetRTCPAutoSend(EFalse);

   456 		}

   457 

   458 

   459 	LOG_FUNC_EXIT("CRtpManager::CreateSessionL");

   460 

   461 	return sessionInfo->iKey;

   462 	}

   463    

   464 

   465 /**

   466  *Create a new, secure RTP Session and return the Session ID as well as the

   467 * local port number assigned for RTP. RTP uses an even port number and

   468 * RTCP, if enabled, uses the next higher (odd) port number.

   469 * User is expected to create corresponding SRTP session prior to calling this

   470 * function. 

   471 */

   472  TRtpId CRtpManager::CreateSessionL( const TCreateSessionParams& aSessionParams, TUint& aPort, 

   473 	                				TBool aEnableRtcp, const TRtcpParams* aRtcpParams, CSRTPSession& aSRTPSession)

   474 	{

   475 	LOG_FUNC_ENTRY("CRtpManager::CreateSessionL");

   476 	__RTP_LOG("SRTP is not supported Leaving..!!")

   477 	

   478 	TUint32 key = CreateSessionL(aSessionParams, aPort, aEnableRtcp, aRtcpParams);

   479 	TInt idx = FindSessionL(key);

   480 	iRtpSessionArr[idx]->iSRTPSession = &aSRTPSession;

   481 	iRtpSessionArr[idx]->iRtpSession.SetPrePostProcessingRegisterCallback(iRtpSessionArr[idx]);

   482 	return key;

   483 	}

   484                             

   485 /**

   486 * Start an RTP Session. If enabled, RTCP associated with the given

   487 * session is also started.

   488 */

   489  TInt CRtpManager::StartSession( TRtpId aSessionId )

   490 	{

   491 	LOG_FUNC_ENTRY("CRtpManager::StartSession");

   492 	if(FindSession(aSessionId)!= KErrNotFound)

   493 		{

   494 		/* Well we found the session. But Really nothing to do */

   495 		//TODO verify

   496 		return KErrNone;

   497 		}

   498 	else

   499 		{

   500 		return KErrNotFound;

   501 		}

   502 	}

   503 

   504 /**

   505 * Close an RTP Session.

   506 */

   507  void CRtpManager::CloseSession( TRtpId aSessionId )

   508 	{

   509 	LOG_FUNC_ENTRY("CRtpManager::CloseSession");

   510 	__RTP_LOG1("SessID %u",aSessionId)

   511 	TInt idx;

   512 	idx = FindSession(aSessionId);

   513 	if(KErrNotFound != idx)

   514 		{

   515 		/* This takes care of all cleaning up */

   516 		iRtpSessionArr[idx]->iRtpSession.Close();

   517 		/* There should be no more Pending requests on this session */

   518 		ASSERT(iRtpSessionArr[idx]->iPendingReqQue->IsEmpty());

   519 		delete iRtpSessionArr[idx]->iPendingReqQue;

   520 		CRtpSessionInfo *session = iRtpSessionArr[idx];

   521 		iRtpSessionArr.Remove(idx);

   522 		delete session;

   523 		}

   524 	else

   525 		{

   526 		__RTP_LOG("Session not found")

   527 	    //So already cleaned?	

   528 		}

   529 	LOG_FUNC_EXIT("CRtpManager::CloseSession");

   530 	}

   531 

   532 /**

   533 * Set remote IP address and port number to RTP Session.

   534 * Port number for RTP must be an even number and the corresponding

   535 * RTCP, if enabled, will be set to use the next higher (odd) port.

   536 */

   537  TInt CRtpManager::SetRemoteAddress( TRtpId aSessionId,const TInetAddr& aRemoteAddr )

   538 	{

   539 	LOG_FUNC_ENTRY("CRtpManager::SetRemoteAddress");

   540 	__RTP_LOG1("SessID %u",aSessionId)

   541 	__RTP_LOG_STMT(TBuf<50> buf; aRemoteAddr.Output(buf););

   542 	__RTP_LOG2("RemoteAddressAddress %S, Port %u", &buf, aRemoteAddr.Port());

   543 	TInt ret;

   544 	TInetAddr addr = aRemoteAddr;

   545 	if((ret =FindSession(aSessionId))!= KErrNotFound)

   546 		{

   547 		iRtpSessionArr[ret]->iRtpSession.SetRemoteAddress(addr);

   548 		iRtpSessionArr[ret]->iRemoteAddress = aRemoteAddr;

   549 		/* SET the RTCP address as well here */

   550 		iRtpSessionArr[ret]->iRemoteRTCPAddress = aRemoteAddr;

   551 		iRtpSessionArr[ret]->iRemoteRTCPAddress.SetPort(aRemoteAddr.Port()+1);

   552 

   553 		return KErrNone;

   554 		}

   555 	else

   556 		{

   557 		return KErrNotFound;

   558 		}

   559 	}

   560 

   561 /**

   562 * Set remote RTCP IP address and port number to RTP Session accoring to RFC 3605

   563 * i.e. this should be used if RTCP port is different than RTP port + 1

   564 */

   565 TInt CRtpManager::SetRemoteRtcpAddress( TRtpId aSessionId, const TInetAddr&  aRemoteAddr)

   566 	{

   567 	LOG_FUNC_ENTRY("CRtpManager::SetRemoteRtcpAddress");

   568 	__RTP_LOG1("SessID %u",aSessionId)

   569 	__RTP_LOG_STMT(TBuf<50> buf; aRemoteAddr.Output(buf););

   570 	__RTP_LOG2("RemoteAddressAddress %S, Port %u", &buf, aRemoteAddr.Port());

   571 	TInt ret;

   572 	TInt port = aRemoteAddr.Port();

   573 	if((ret =FindSession(aSessionId))!= KErrNotFound)

   574 		{

   575 		iRtpSessionArr[ret]->iRtpSession.SetRemoteRtcpPort(port);

   576 		iRtpSessionArr[ret]->iRemoteRTCPAddress = aRemoteAddr;

   577         

   578 		/*

   579 		//VS Experiment. Try sending Door opener here to Remote end

   580     	TRequestStatus 	stat;

   581 		__RTP_LOG("CRtpManager::SetRemoteAddress -- Sending DoorOpener --RTCP");

   582 		RSocket *sock = NULL;

   583 		sock = GetRtcpSocket(aSessionId);

   584 		sock->SendTo(_L8("OpenSesame"),iRtpSessionArr[ret]->iRemoteAddress,0,stat);

   585 		User::WaitForRequest(stat);

   586         __RTP_LOG1("DoorOpener --RTCP sent retCode %d", stat.Int());

   587 		LOG_FUNC_EXIT("CRtpManager::SetRemoteRtcpAddress");

   588 		*/

   589 		return KErrNone;

   590 		}

   591 	else

   592 		{

   593 		return KErrNotFound;

   594 		}

   595 	}

   596         

   597 /**

   598 * Create a Receive stream for an RTP Session and return the stream

   599 * ID which is unique for all RTP Sessions.

   600 */

   601  TRtpId CRtpManager::CreateReceiveStreamL( TRtpId aSessionId, const TRcvStreamParams& aParams )

   602 	{

   603 	LOG_FUNC_ENTRY("CRtpManager::CreateReceiveStreamL");

   604 	__RTP_LOG1("SessID %u",aSessionId)

   605 	/* Valide the session */

   606 	FindSessionL(aSessionId);

   607 	

   608 	/* Check for Post-Created Streams. If present use it */

   609 	for(TInt i=0; i < iRtpStreamsArr.Count(); i++)

   610 		{

   611 		if(iRtpStreamsArr[i].iSessionKey == aSessionId &&

   612 				iRtpStreamsArr[i].iState == TRtpStreamInfo::eStreamPostCreated && 

   613 				iRtpStreamsArr[i].iPayloadType == aParams.iPayloadType	)

   614 			{

   615 			__RTP_LOG1("Found Post Created Stream Key %u",iRtpStreamsArr[i].iKey)

   616 			/* Post created stream exists. Return it */

   617 			iRtpStreamsArr[i].iState = TRtpStreamInfo::eStreamReadyToUse;

   618 			return iRtpStreamsArr[i].iKey;

   619 			}

   620 		}

   621 	

   622 	/* OK found nothing. So create a Pre-Created stream and return its ID */

   623 	TRtpStreamInfo strmInfo;

   624 	strmInfo.iKey = Math::Random();

   625 	strmInfo.iSessionKey = aSessionId;

   626 	strmInfo.iState = TRtpStreamInfo::eStreamPreCreated;

   627 	strmInfo.iPayloadType = aParams.iPayloadType;

   628 	strmInfo.iRtpManager = this;

   629 	

   630 	iRtpStreamsArr.AppendL(strmInfo);

   631 	__RTP_LOG1("Created PreCreated Stream Key %u",strmInfo.iKey)

   632 	

   633 	LOG_FUNC_EXIT("CRtpManager::CreateReceiveStreamL");

   634 	return strmInfo.iKey;

   635 	}

   636 

   637  /**

   638   * Create a Transmit stream for an RTP Session and return the stream

   639   * ID which is unique for all RTP Sessions. SSRC value assigned for the

   640   * very first Transmit stream will be the same as the default SSRC

   641   * value reserved internally by CreateSession function. This function

   642   * is normally used to create a transmit stream where SSRC value is

   643   * randomly generated.

   644   */

   645    TRtpId CRtpManager::CreateTransmitStreamL( TRtpId aSessionId,

   646                       const TTranStreamParams& aParams,

   647                       TRtpSSRC& aSSRC )

   648 	   {

   649 	   LOG_FUNC_ENTRY("CRtpManager::CreateTransmitStreamL");

   650 	   __RTP_LOG1("SessID %u",aSessionId)

   651 	   TInt idx = FindSessionL(aSessionId);

   652 	   if(!iRtpSessionArr[idx]->iRtpSendSource.IsOpen())

   653 		   {

   654 		   iRtpSessionArr[idx]->iRtpSendSource = iRtpSessionArr[idx]->iRtpSession.NewSendSourceL();

   655 		   /* Now register for events in this session */

   656 		   iRtpSessionArr[idx]->iRtpSendSource.RegisterEventCallbackL(ERtpSendSucceeded,

   657 				                                          RtpSessionLevelCB,

   658 				                                          iRtpSessionArr[idx],

   659 				                                          ERtpNotOneShot);

   660 		   iRtpSessionArr[idx]->iRtpSendSource.RegisterEventCallbackL(ERtpSendFail,

   661 				                                          RtpSessionLevelCB,

   662 				                                          iRtpSessionArr[idx],

   663 				                                          ERtpNotOneShot);

   664 		   aSSRC = iRtpSessionArr[idx]->iRtpSendSource.GetLocalSSRC();

   665 		   

   666 		   iRtpSessionArr[idx]->iPayloadType = aParams.iPayloadType;

   667 		   

   668 		   iRtpSessionArr[idx]->iRtpSendSource.SetPayloadType(aParams.iPayloadType);

   669 		   

   670                

   671            //Note: The key is same as the SessionKey. We donot support

   672            //more than one Transmit Streams in one Session.

   673            LOG_FUNC_EXIT("CRtpManager::CreateTransmitStreamL");

   674                

   675            return iRtpSessionArr[idx]->iKey;

   676            }

   677 	   __RTP_LOG("A SendStream was already Opened!")

   678 	   //Already called still there might be Applications calling this

   679 	   //API twice

   680 	   //

   681 	   LOG_FUNC_EXIT("CRtpManager::CreateTransmitStreamL");

   682 	   return 0;

   683 	   }

   684 

   685   /**

   686   * Create a Transmit stream, with a given SSRC value, for an RTP Session

   687   * and return the stream ID which is unique for all RTP Sessions. This

   688   * extended function is used for a special case where a specific SSRC

   689   * value needs to be associated with the transmit stream being created,

   690   * e.g. for retransmission purpose.

   691   */

   692    TRtpId CRtpManager::CreateTransmitStreamExtL( TRtpId , const TTranStreamParams& ,

   693                       							const TRtpSSRC )

   694 	   {

   695 	   LOG_FUNC_ENTRY("CRtpManager::CreateTransmitStreamL");

   696 	   __RTP_LOG("NotSuppoted SSRC cannot be changed")

   697 	   //This is not supported as of now.

   698 	   //SSRC cannot be specified by Applications.

   699 	   return 0;

   700 	   }

   701 

   702 

   703    /**

   704     * Close a Transmit or Receive stream.

   705     */

   706 void CRtpManager::CloseStream( TRtpId aRtpID)

   707 	   {

   708 	   LOG_FUNC_ENTRY("CRtpManager::CloseStream");

   709 	   __RTP_LOG1("Stream ID %u",aRtpID)

   710        (void)aRtpID;

   711 	   //Streams are closed when session is closed.

   712 	   //so no requirement for an explicit close

   713 	   //TODO Verify Requirements

   714 	   return;

   715 	   }

   716 

   717 /**

   718  * Register a callback object for receiving RTP data packets from an RTP

   719  * Session. Only one receiver callback object is allowed to be

   720  * registered for one Session.

   721  */

   722 TInt CRtpManager::RegisterRtpObserver( TRtpId aSessionId, MRtpObserver& aRtpObserver )

   723 	{

   724 	LOG_FUNC_ENTRY("CRtpManager::RegisterRtpObserver");

   725 	__RTP_LOG1("SessID %u",aSessionId)

   726 	TInt ret = FindSession(aSessionId);

   727 	if(ret < 0)

   728 		return ret;

   729 	iRtpSessionArr[ret]->iRtpObserver = &aRtpObserver;

   730 	return KErrNone;

   731 	}

   732 

   733  /**

   734   * Unregister RTP observer callback object associated with an RTP

   735   * session.

   736   */

   737 void CRtpManager::UnregisterRtpObserver(TRtpId aSessionId)

   738 	{	

   739 	LOG_FUNC_ENTRY("CRtpManager::UnregisterRtpObserver");

   740 	__RTP_LOG1("SessID %u",aSessionId)

   741 

   742 	TInt ret = FindSession(aSessionId);

   743 	if(ret >= 0)

   744 		iRtpSessionArr[ret]->iRtpObserver = NULL;

   745 	}

   746 

   747 /**

   748 * Sets/resets the observer for the non-RTP data.

   749 * Only one receiver callback object is allowed to be

   750 * registered for one Session.

   751 * called when a non-RTP data packet is received.

   752 */

   753  TInt CRtpManager::SetNonRTPDataObserver( TRtpId aSessionId, MNonRTPDataObserver* aNonRtpObserver)

   754 	{

   755 	LOG_FUNC_ENTRY("CRtpManager::SetNonRTPDataObserver");

   756 	__RTP_LOG1("SessID %u",aSessionId);

   757 	

   758 	TInt ret = FindSession(aSessionId);

   759 	if(ret < 0)

   760 		return ret;

   761 	iRtpSessionArr[ret]->iNonRtpDataObserver = aNonRtpObserver;

   762 	

   763 	TRAPD(err,iRtpSessionArr[ret]->iRtpSession.RegisterEventCallbackL(ENonRtpDataReceived,

   764 			                                          RtpSessionLevelCB,

   765 			                                          iRtpSessionArr[ret],

   766 			                                          ERtpOneShot));

   767 	if(KErrNone != err)

   768 		{

   769 		__RTP_LOG1("err %d",err);

   770 		return err;

   771 		}

   772 

   773 	TRAP(err,iRtpSessionArr[ret]->iRtpSession.RegisterEventCallbackL(ENonRtcpDataReceived,

   774 				                                          RtpSessionLevelCB,

   775 				                                          iRtpSessionArr[ret],

   776 				                                          ERtpOneShot));

   777 	

   778 	if(KErrNone != err)

   779 		{

   780 		/* The already registered callback will be deleted when the first

   781 		 * NonRtp data comes

   782 		 */

   783 		iRtpSessionArr[ret]->iNonRtpDataObserver = 0;

   784 		}

   785 	return err;

   786 	}

   787 

   788 /**

   789 * Send an RTP data packet in a Transmit stream synchronously.

   790 */

   791  TInt CRtpManager::SendRtpPacket( TRtpId aTranStreamId,

   792                              const TRtpSendHeader& aHeaderInfo,

   793                              const TDesC8& aPayloadData )

   794 	{

   795 	LOG_FUNC_ENTRY("CRtpManager::SendRtpPacket");

   796 	__RTP_LOG1("aTranStreamId: %u",aTranStreamId)

   797 

   798 	/* The Transmit Id and Session ID are same. So

   799 	 * find the session */

   800 	TInt ret = FindSession(aTranStreamId);

   801 	if(ret<0)

   802 		return ret;

   803 	ASSERT(iRtpSessionArr[ret]->iRtpSendSource.IsOpen());

   804 	

   805 	RRtpSendPacket sendPkt;

   806 	TInt pktLen = 0;

   807     pktLen += aPayloadData.Length();

   808     __RTP_LOG1("pktLen: %d", pktLen );	

   809     if(iRtpSessionArr[ret]->iSRTPSession)

   810 		{

   811 		/* SRTP is enabled so allocate more bytes for MKI and AuthTag */

   812 		pktLen += ( KSrtpMaxAuthTagLength + KSrtpMaxMKILen );

   813 	    __RTP_LOG1("Added extra bytes for SRTP new pktLen: %d", pktLen );	

   814 		}	

   815 	TRAPD(err,sendPkt = iRtpSessionArr[ret]->iRtpSendSource.NewSendPacketL(pktLen, aHeaderInfo.iHeaderExtension?aHeaderInfo.iHeaderExtension->iLength:KRtpNoExtension));

   816 	if(err != KErrNone)

   817 		return err;

   818 	

   819 	__RTP_LOG2("TS: %u, PayloadType %d",aHeaderInfo.iTimestamp, aHeaderInfo.iPayloadType)

   820 	sendPkt.SetTimestamp(aHeaderInfo.iTimestamp);

   821 	sendPkt.SetMarker(aHeaderInfo.iMarker);

   822 	sendPkt.SetPayloadType(aHeaderInfo.iPayloadType);

   823 	

   824 	if(iRtpSessionArr[ret]->iFirstPacketSent == EFalse)

   825 	    {

   826 	    iRtpSessionArr[ret]->iRtpSession.SetRTPTimeConversion(aHeaderInfo.iTimestamp, iRtpSessionArr[ret]->iSamplingRate/1000);

   827 	    iRtpSessionArr[ret]->iFirstPacketSent = ETrue;

   828 	    }

   829 

   830 	TDes8 &wrtPayload = sendPkt.WritePayload();

   831 	wrtPayload = aPayloadData;

   832 	

   833 	ret = sendPkt.SendSync();

   834 	

   835 	//TODO pre allocate a Max Size

   836 	sendPkt.Close();

   837 	

   838 	LOG_FUNC_EXIT("CRtpManager::SendRtpPacket");	

   839 	return ret;

   840 	}

   841  

   842  

   843  /**

   844    * Send an RTP data packet in a Transmit stream asynchronously.

   845    */

   846  TInt CRtpManager::SendRtpPacket( TRtpId aTranStreamId,

   847                                 const TRtpSendHeader& aHeaderInfo,

   848                                 const TDesC8& aPayloadData,

   849                                 TRequestStatus& aStatus )

   850 	{

   851 	LOG_FUNC_ENTRY("CRtpManager::SendRtpPacket");

   852 	__RTP_LOG1("aTranStreamId: %u",aTranStreamId)

   853 	/* The Transmit Id and Session ID are same. So

   854 	 * find the session */

   855 	TInt ret = FindSession(aTranStreamId);

   856 	if(ret<0)

   857 		return ret;

   858 	ASSERT(iRtpSessionArr[ret]->iRtpSendSource.IsOpen());

   859 	

   860 	RRtpSendPacket sendPkt;

   861 	TInt pktLen = 0;

   862     pktLen += aPayloadData.Length();

   863     __RTP_LOG1("pktLen: %d", pktLen );	

   864     if(iRtpSessionArr[ret]->iSRTPSession)

   865 		{

   866 		/* SRTP is enabled so allocate more bytes for MKI and AuthTag */

   867 		pktLen += ( KSrtpMaxAuthTagLength + KSrtpMaxMKILen );

   868 	    __RTP_LOG1("Added extra bytes for SRTP new pktLen: %d", pktLen );	

   869 		}	

   870 	TRAPD(err,sendPkt = iRtpSessionArr[ret]->iRtpSendSource.NewSendPacketL(pktLen,aHeaderInfo.iHeaderExtension?aHeaderInfo.iHeaderExtension->iLength:KRtpNoExtension));

   871 	if(err != KErrNone)

   872 		return err;

   873 

   874     __RTP_LOG2("TS: %u, PayloadType %d",aHeaderInfo.iTimestamp, aHeaderInfo.iPayloadType);	

   875 	sendPkt.SetTimestamp(aHeaderInfo.iTimestamp);

   876 	sendPkt.SetMarker(aHeaderInfo.iMarker);

   877 	sendPkt.SetPayloadType(aHeaderInfo.iPayloadType);

   878 

   879 	

   880 	if(iRtpSessionArr[ret]->iFirstPacketSent == EFalse)

   881 		{

   882 		iRtpSessionArr[ret]->iRtpSession.SetRTPTimeConversion(aHeaderInfo.iTimestamp, 1000*1000/iRtpSessionArr[ret]->iSamplingRate);

   883 		iRtpSessionArr[ret]->iFirstPacketSent = ETrue;

   884 		}

   885 

   886 	

   887 	TDes8 &wrtPayload = sendPkt.WritePayload();

   888 	wrtPayload = aPayloadData;

   889 	

   890 	/* This is an Async Send. So insert this packet in to the 

   891 	 * the send queue.

   892 	 */

   893 	TRtpSendReqNode *sendReqNode = NULL;

   894 	sendReqNode = new TRtpSendReqNode();

   895 	if(!sendReqNode)

   896 		{

   897 		sendPkt.Close();

   898 		return KErrNoMemory;

   899 		}

   900 	

   901 	sendReqNode->iPktToSend = sendPkt;

   902 	sendReqNode->iStatus = &aStatus;

   903 	iRtpSessionArr[ret]->iPendingReqQue->AddFirst(*sendReqNode);

   904 	*sendReqNode->iStatus = KRequestPending;

   905 	/* If this is the only pending element in the queue schedule immediately */

   906 	if(iRtpSessionArr[ret]->iPendingReqQue->IsLast(sendReqNode))

   907 		{

   908 		__RTP_LOG("Async Send ..Sending Immediately!");

   909 	    return SendRtpDataFromPendingQueue(iRtpSessionArr[ret]);	

   910 		}

   911 	

   912 	__RTP_LOG("Async Send ..Packet Queued!");

   913 	//TODO pre allocate a Max Size

   914     // The packet will be closed when Send is completed

   915 	return KErrNone;

   916 	}

   917 

   918  /**

   919    * Send an RTP data packet asynchronously, with a given sequence number,

   920    * in a Transmit stream mainly for retransmission purpose.

   921  */

   922  TInt CRtpManager::SendRtpPacket( TRtpId aTranStreamId,

   923                                 TRtpSequence ,

   924                                 const TRtpSendHeader& aHeaderInfo,

   925                                 const TDesC8& aPayloadData,

   926                                 TRequestStatus& aStatus )

   927 	{

   928     LOG_FUNC_ENTRY("CRtpManager::SendRtpPacket - With Sequence Called!!");

   929     //TODO We SHOULD consider the Sequence number as well!	

   930 	return SendRtpPacket(aTranStreamId, aHeaderInfo, aPayloadData, aStatus) ;

   931 	}

   932 

   933 

   934 /**

   935   * Send a non-RTP (control) data packet asynchronously

   936 */

   937  void CRtpManager::SendDataL( TRtpId aSessionId, TBool aUseRTPSocket, 

   938 		                      const TDesC8& aData, TRequestStatus&  aStatus)

   939 	{

   940 	LOG_FUNC_ENTRY("CRtpManager::SendDataL");

   941 	__RTP_LOG1("aSessionId: %u",aSessionId)

   942 	TInt ret = FindSessionL(aSessionId);

   943 	RSocket *sock = NULL;

   944 	TInetAddr remAddr = iRtpSessionArr[ret]->iRemoteAddress;

   945 	if(aUseRTPSocket)

   946 		{

   947 		sock = GetRtpSocket(aSessionId);

   948 		}

   949 	else

   950 		{

   951 		if(!iRtpSessionArr[ret]->iRtcpEnabled)

   952 			User::Leave(KErrNotSupported);

   953 		sock = GetRtcpSocket(aSessionId);

   954 		remAddr = iRtpSessionArr[ret]->iRemoteRTCPAddress;

   955 		}

   956 	/* Send the data out through the Socket */

   957 	sock->SendTo(aData,remAddr,0,aStatus);

   958 	return;

   959 	}

   960 

   961  /**

   962   * Cancel an outstanding SendRtpPacket() operation.

   963   */

   964  void CRtpManager::CancelSend( TRtpId aSessId)

   965 	 {

   966 	 /* Its a Bit tricky here. 

   967 	  * We have two levels of Active Objects and the Symbian stack

   968 	  * do not provide any API to cancel the Send request. As a workarnd we accesses the

   969 	  * RTP Socket directly and cancels the send ( RSocket::CancelSend())

   970 	  * Internal statistics are not rolled back in this case, but surely we can

   971 	  * live with that.

   972 	  * 

   973 	  * The Active object who issued this call will do a User::WaitForRequest() 

   974 	  * immediatly after calling Cancel. (See CActive::Cancel() implementation).

   975 	  * This means we should complete the request with KErrCancel here itself or

   976 	  * thread will block (Because we are not exactly an Async Service provider).

   977 	  * Once the request is completed we can expect a ESendFail callback or an

   978 	  * ESendSuccess callback from stack ( Second one beacuse the request might have

   979 	  * been completed already).

   980 	  */

   981 	LOG_FUNC_ENTRY("CRtpManager::CancelSend");

   982 	__RTP_LOG1("SessId: %u",aSessId)

   983 

   984 	TInt ret = FindSession(aSessId);

   985 	if(ret < 0)

   986 		{

   987 		ASSERT(ret!=KErrNone);

   988 		return;

   989 		}

   990 	if(iRtpSessionArr[ret]->iPendingReqQue->IsEmpty())

   991 		{

   992 		/* There is no pending request. This probably means the request was

   993 		 * already completed but the App is yet to see it..

   994 		 */

   995 		__RTP_LOG("NO pending request .. Returning!")

   996 		return;

   997 		}

   998 	

   999 	TRtpSendReqNode *reqNode = iRtpSessionArr[ret]->iPendingReqQue->Last();

  1000     /* Once send is canceled complete Applications request. Also if the pending

  1001 	 * queue is not empty schedule a new transmission here itself */

  1002 	iRtpSessionArr[ret]->iRtpSendSource.Cancel();

  1003 	User::RequestComplete(reqNode->iStatus, KErrCancel);

  1004 	iRtpSessionArr[ret]->iPendingReqQue->Remove(*reqNode);

  1005 	reqNode->iPktToSend.Close();

  1006 	delete reqNode;

  1007 

  1008 	if(!iRtpSessionArr[ret]->iPendingReqQue->IsEmpty())

  1009 		{

  1010 		__RTP_LOG("Scheduling another send from PendingQueue")

  1011 		SendRtpDataFromPendingQueue(iRtpSessionArr[ret]);

  1012 		}

  1013 

  1014 	return;

  1015 	}

  1016 

  1017   /**

  1018   * Register a callback object for receiving RTCP packets associated with

  1019   * a given RTP Session. Only one observer callback object is allowed to

  1020   * be registered. One of aRtcpObserver object's callback functions is

  1021   * called when an RTCP packet of that type is received.

  1022   */

  1023  TInt CRtpManager::RegisterRtcpObserver( TRtpId aSessionId, MRtcpObserver& aRtcpObserver )

  1024 	 {

  1025 	LOG_FUNC_ENTRY("CRtpManager::RegisterRtcpObserver");

  1026 	__RTP_LOG1("SessId: %u",aSessionId)

  1027 

  1028 	 TInt ret = FindSession(aSessionId);

  1029 	 if(ret < 0)

  1030 	 	return ret;

  1031 	 iRtpSessionArr[ret]->iRtcpObserver = &aRtcpObserver;

  1032 	 return KErrNone;

  1033 	 }

  1034 

  1035   /**

  1036   * Unregister RTCP observer callback object associated with an RTP

  1037   * session.

  1038   */

  1039  void CRtpManager::UnregisterRtcpObserver( TRtpId aSessionId )

  1040 	 {

  1041 	 LOG_FUNC_ENTRY("CRtpManager::UnregisterRtcpObserver");

  1042 	 __RTP_LOG1("SessId: %u",aSessionId)

  1043 

  1044 	 TInt ret = FindSession(aSessionId);

  1045 	 if(ret >= 0)

  1046 		 iRtpSessionArr[ret]->iRtcpObserver = NULL; 

  1047 	 return;

  1048 	 }

  1049  /**

  1050  * Send an RTCP APP packet for a Transmit stream.

  1051  */

  1052  TInt CRtpManager::SendRtcpAppPacket( TRtpId aTranStreamId, const TRtcpApp& aApp )

  1053 	 {

  1054 	 LOG_FUNC_ENTRY("CRtpManager::SendRtcpAppPacket");

  1055 	 __RTP_LOG1("aTranStreamId: %u",aTranStreamId)

  1056 

  1057 	 /* A send stream should be open to send an RTCP Bye packet */

  1058 	 //Transmit Stream ID and Session Id are same

  1059 	 TInt ret = FindSession(aTranStreamId);

  1060 	 if(ret < 0)

  1061 	 	return ret;

  1062 	 ASSERT(iRtpSessionArr[ret]->iRtcpEnabled);

  1063 	 

  1064 	 TPtrC8 appName;

  1065 	 appName.Set(aApp.iName,4); //Name is 4 Characters RFC 3550 Sec 6.7

  1066 	 

  1067 	 TPtrC8 appData;

  1068 	 appData.Set(aApp.iAppData,aApp.iAppDataLen);

  1069 	 

  1070 	 TUint8 subType = aApp.iSubType;

  1071 	 

  1072 	 TRAPD(err,iRtpSessionArr[ret]->iRtpSession.SendAPPL(appName,appData, subType));

  1073 	 

  1074 	 return err;

  1075 	 }

  1076 

  1077  /**

  1078   * Send an RTCP BYE packet for a Transmit stream.

  1079  */

  1080  TInt CRtpManager::SendRtcpByePacket( TRtpId aTranStreamId, const TDesC8& aReason)

  1081 	 {

  1082 	 LOG_FUNC_ENTRY("CRtpManager::SendRtcpByePacket");

  1083 	 __RTP_LOG1("aTranStreamId: %u",aTranStreamId)

  1084 

  1085 	 /* A send stream should be open to send an RTCP Bye packet */

  1086 	 //Transmit Stream ID and Session Id are same

  1087 	 TInt ret = FindSession(aTranStreamId);

  1088 	 if(ret < 0)

  1089 	 	return ret;

  1090 	 ASSERT(iRtpSessionArr[ret]->iRtpSendSource.IsOpen());

  1091 	 TRAPD(err,iRtpSessionArr[ret]->iRtpSendSource.ByeL(const_cast<TDesC8&>(aReason)));

  1092 	 return err;

  1093 	 }

  1094 

  1095 /** 

  1096  * Send an RTCP RR packet for a Reception stream.

  1097 */

  1098 TInt CRtpManager::SendRtcpRrPacket( TRtpId aRcvStreamId )

  1099 	{

  1100 	 LOG_FUNC_ENTRY("CRtpManager::SendRtcpRrPacket");

  1101 	 __RTP_LOG1("aRcvStreamId: %u",aRcvStreamId)

  1102 

  1103     /* No specific way to Send an RR Report alone */

  1104 	//Do we need to?

  1105 	TInt ret = FindStream(aRcvStreamId);

  1106 	if(ret<0)

  1107 		{

  1108 		return ret;

  1109 		}

  1110 

  1111 	ret = FindSession(iRtpStreamsArr[ret].iSessionKey);

  1112 	TUint8 flg = 0x81;

  1113 	TBuf8<1> flags;

  1114 	flags.Copy(&flg,1);

  1115 	TRAP(ret, iRtpSessionArr[ret]->iRtpSession.SendRTCPPacketL(flags));

  1116 	return ret;

  1117 	}

  1118  

  1119  /** 

  1120  * Send an RTCP SR packet for a Transmit stream.

  1121  */

  1122  TInt CRtpManager::SendRtcpSrPacket( TRtpId aTranStreamId )

  1123  	{

  1124 	 LOG_FUNC_ENTRY("CRtpManager::SendRtcpSrPacket");

  1125 	 __RTP_LOG1("aTranStreamId: %u",aTranStreamId)

  1126 

  1127 	//NOTE: TransID same as SessionId

  1128 	TInt ret = FindSession(aTranStreamId);

  1129 	if(ret<0)

  1130 		return ret;

  1131 	

  1132 	TUint8 flg = 0x81;

  1133 	TBuf8<1> flags;

  1134 	flags.Copy(&flg,1);

  1135     TRAP(ret, iRtpSessionArr[ret]->iRtpSession.SendRTCPPacketL(flags));