diff -r 000000000000 -r 1bce908db942 multimediacommsengine/tsrc/MCETestUI/MCETestUIEngine/src/CMCETestUIEngineOutSession.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/multimediacommsengine/tsrc/MCETestUI/MCETestUIEngine/src/CMCETestUIEngineOutSession.cpp Tue Feb 02 01:04:58 2010 +0200 @@ -0,0 +1,1532 @@ +/* +* Copyright (c) 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: +* +*/ + + + + +// MCE API +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "MCETestUIEngineDefaultValues.h" +#include "CMCETestUIQuestionDataQuery.h" +#include "CMCETestUIEngine.h" +#include "CMCETestUIEngineProfileContainer.h" +#include "CMCETestUIEngineProfile.h" +#include "CMCETestUIEngineOutSession.h" +#include "TMCETestUIEngineCmdEstablish.h" +#include "TMCETestUIEngineCmdCancelSession.h" +#include "TMCETestUIEngineCmdDeleteSession.h" +#include "TMCETestUIEngineCmdFloorControlSession.h" +#include "CMCETestUIEngineMultimediaObserver.h" +#include "TMCETestUIEngineCmdCryptoHandling.h" + +#include "TMCETestUIEngineCmdSRReqRes.h" + + + +//const TUint KAudioPrefAudioUplink = 0x05220001; +//const TUint KAudioPrefAudioDownlink = 0x05210001; + + +const TUint KJitterBufferInactTimeout = 10000; + +_LIT8( KMCERtpSinkIdentity, "RtpSink@multimedia.engine.com" ); +_LIT8( KMCERtpSourceIdentity, "RtpSource@multimedia.engine.com" ); + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::NewL() +// ----------------------------------------------------------------------------- +// +CMCETestUIEngineOutSession* CMCETestUIEngineOutSession::NewL( + CMCETestUIEngine& aEngine, + CMCETestUIEngineProfile& aProfile, + TDirection aDirection, + TVideoDirection aVideoDirection, + TSessionType aSessionType ) + { + + CMCETestUIEngineOutSession* self = + new (ELeave) CMCETestUIEngineOutSession( aEngine, + aProfile, + aDirection, + aVideoDirection, + aSessionType ); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::NewL() +// ----------------------------------------------------------------------------- +// +CMCETestUIEngineOutSession* CMCETestUIEngineOutSession::NewL( + CMCETestUIEngine& aEngine, + TUint32 aIAPId, + TDirection aDirection, + TVideoDirection aVideoDirection, + TSessionType aSessionType ) + { + + CMCETestUIEngineOutSession* self = + new (ELeave) CMCETestUIEngineOutSession( aEngine, + aIAPId, + aDirection, + aVideoDirection, + aSessionType ); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::NewL() +// ----------------------------------------------------------------------------- +// +CMCETestUIEngineOutSession* CMCETestUIEngineOutSession::NewL( + CMCETestUIEngine& aEngine, + CMceRefer &aRefer, + TDirection aDirection, + TVideoDirection aVideoDirection, + TSessionType aSessionType ) + { + + CMCETestUIEngineOutSession* self = + new (ELeave) CMCETestUIEngineOutSession( aEngine, + aRefer, + aDirection, + aVideoDirection, + aSessionType ); + CleanupStack::PushL( self ); + self->ConstructL(aRefer); + CleanupStack::Pop( self ); + return self; + } +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::CMCETestUIEngineOutSession +// ----------------------------------------------------------------------------- +// +CMCETestUIEngineOutSession::CMCETestUIEngineOutSession( + CMCETestUIEngine& aEngine, + CMCETestUIEngineProfile& aProfile, + TDirection aDirection, + TVideoDirection aVideoDirection, + TSessionType aSessionType ) + : CMCETestUIEngineSession( aEngine, aDirection,aVideoDirection ), + iProfile( &aProfile ), + iId( 0 ), + iSessionType(aSessionType), + iIapId ( 0xFF ) + { + } + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::CMCETestUIEngineOutSession +// ----------------------------------------------------------------------------- +// +CMCETestUIEngineOutSession::CMCETestUIEngineOutSession( + CMCETestUIEngine& aEngine, + TUint32 aIAPId, + TDirection aDirection, + TVideoDirection aVideoDirection, + TSessionType aSessionType ) + : CMCETestUIEngineSession( aEngine, aDirection,aVideoDirection ), + iIapId( aIAPId ), + iId( 0 ), + iSessionType(aSessionType), + iProfile ( NULL ) + { + } + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::CMCETestUIEngineOutSession +// ----------------------------------------------------------------------------- +// +CMCETestUIEngineOutSession::CMCETestUIEngineOutSession( + CMCETestUIEngine& aEngine, + CMceRefer &aRefer, + TDirection aDirection, + TVideoDirection aVideoDirection, + TSessionType /*aSessionType*/ ) + : CMCETestUIEngineSession( aEngine, aDirection,aVideoDirection ), + iId( 0 ), + iRefer(&aRefer) + + { + } +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::ConstructL() +// ----------------------------------------------------------------------------- +// +void CMCETestUIEngineOutSession::ConstructL() + { + + ///////////////////// + // + // TODO: After implementing wrappers for streams, sinks and sources + // this function should be refactored to make use of them. That will + // also simplify the function to some extent. + // + ////////////////////// + BaseConstructL(); + FillProfileRegistrar(); + FillPoCOrigAddress(); + if( SessionParamsL(iSessionParams,iSessionType) ) + { + // set rtcp flag + if(iEngine.iRtcpFlag == EFalse) + { + iEngine.iSRCount = 0; + iEngine.iRRCount = 0; + } + + + // Solve recipient + CMCETestUIQuestionDataQuery* question = + CMCETestUIQuestionDataQuery::NewLC(); + + question->SetCaptionL( KUserQuestionInputRecipient ); + question->SetDefaultValueL(iSessionParams.iRecipentAddress ); + question->SetAnswerL( iSessionParams.iRecipentAddress ); + TBufC8<300> recipient( question->Answer8() ); + + CleanupStack::PopAndDestroy( question ); + + ////// + // solve originator + CMceOutSession* outSession = NULL; + + if( iSessionParams.originator.Compare(KNone) )//if there is originator + { + HBufC8* orig8 = HBufC8::NewL(iSessionParams.originator.Length()); + TPtr8 ptr = orig8->Des(); + ptr.Copy(iSessionParams.originator); + // Create Outsession + if(iEngine.iOutSessionWithProfile)// thru profile + { + + if( iSessionParams.iSecureSession ) + { + iOutSession = + CMceSecureOutSession::NewL( iEngine.MCEManager(), + iProfile->Profile(), + recipient ,orig8); + if( iEngine.iSecureSessionAVP ) + { + iOutSession->SetModifierL( KMceSecureSession, + KMceSecurePlainAVP ); + } + + if ( iEngine.iSecPreconditions ) + { + iOutSession->SetModifierL( KMceSecPreconditions, + KMcePreconditionsE2ESupported ); + } + + } + else + { + iOutSession = CMceOutSession::NewL( iEngine.MCEManager(), + iProfile->Profile(), + recipient ,orig8); + } + + } + else ///thru accesspoint , it can be done only with originator + { + iOutSession = CMceOutSession::NewL( iEngine.MCEManager(), + iIapId,ptr,recipient); + + } + + } + else // if there is only recipent and no originator + { + if ( iSessionParams.iSecureSession ) + { + iOutSession = + CMceSecureOutSession::NewL( iEngine.MCEManager(), + iProfile->Profile(), + recipient ); + if ( iEngine.iSecureSessionAVP ) + { + iOutSession->SetModifierL( KMceSecureSession, + KMceSecurePlainAVP ); + } + if ( iEngine.iSecPreconditions ) + { + iOutSession->SetModifierL( KMceSecPreconditions, + KMcePreconditionsE2ESupported ); + } + + } + else + { + iOutSession = CMceOutSession::NewL( iEngine.MCEManager(), + iProfile->Profile(), + recipient ); + } + + } + + iSession = iOutSession; + + if ( iSessionType == EPoCSession) + { + FillPoCSessionData(iOutSession); + } + else if (iSessionType == EVoIPSession) + { + FillVoIPSessionData(iOutSession); + } + else if (iSessionType == E2WayVideoSession) + { + Fill2WayVideoSessionDataL(iOutSession); + } + else if (iSessionType == ECustomSession) + { + FillCustomSessionData(iOutSession); + } + if ( iEngine.iHoldWithAddress ) + { + iOutSession->SetModifierL( KMceMediaDirection, KMceMediaDirectionWithAddress ); + } + if ( iEngine.IsFCSession() ) + { + TRAP_IGNORE(iEngine.FloorControl().InitializeL( + *iOutSession,0,iEngine.MMObserver())); + CDesC8Array* array = NULL; + + array = new (ELeave) CDesC8ArrayFlat(1); + array->AppendL(_L8("a=fmtp:TBCP queuing=1; tb_priority=0; timestamp=1; tb_granted=1; poc_sess_priority=1; poc_lock=1\r\n")); + iEngine.FloorControl().UpdateL(*iOutSession, array); + + } + + if ( iEngine.iSdp ) + { + CDesC8Array* array = new (ELeave) CDesC8ArrayFlat(3); + array->AppendL(_L8("a=OutgoingSession1:20\r\n")); + array->AppendL(_L8("a=OutgoingSession2:40\r\n")); + array->AppendL(_L8("b=AS:64\r\n")); + iOutSession->SetSessionSDPLinesL( array ); + } + } + + // Get identity + iId = iEngine.NextOutSessionId(); + iType = KMceOutSession; + + } + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::ConstructSessionFromReferL() +// ----------------------------------------------------------------------------- +// +void CMCETestUIEngineOutSession::ConstructL(CMceRefer& /*aRefer*/) + { + + ///////////////////// + // + // TODO: After implementing wrappers for streams, sinks and sources + // this function should be refactored to make use of them. That will + // also simplify the function to some extent. + // + ////////////////////// + BaseConstructL(); + + CMceOutSession* outSession = NULL; + iOutSession = CMceOutSession::NewL( *iRefer ); + + iSession = iOutSession; + + if ( iSessionType == ECustomSession) + { + // FillCustomSessionData(iOutSession); + FillVoIPSessionData(iOutSession); + } + if( iEngine.iHoldWithAddress ) + { + iOutSession->SetModifierL( KMceMediaDirection, KMceMediaDirectionWithAddress ); + } + if( iEngine.IsFCSession() ) + { + TRAP_IGNORE(iEngine.FloorControl().InitializeL( + *iOutSession,0,iEngine.MMObserver())); + CDesC8Array* array = NULL; + + array = new (ELeave) CDesC8ArrayFlat(1); + array->AppendL(_L8("a=fmtp:TBCP queuing=1; tb_priority=0; timestamp=1; tb_granted=1; poc_sess_priority=1; poc_lock=1\r\n")); + iEngine.FloorControl().UpdateL(*iOutSession, array); + + } + if( iEngine.iSdp ) + { + CDesC8Array* array = new (ELeave) CDesC8ArrayFlat(2); + array->AppendL(_L8("a=OutgoingSession1:20\r\n")); + array->AppendL(_L8("a=OutgoingSession2:40\r\n")); + iOutSession->SetSessionSDPLinesL( array ); + } + + + // Get identity + iId = iEngine.NextOutSessionId(); + iType = KMceOutSession; + + } + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::~CMCETestUIEngineOutSession +// ----------------------------------------------------------------------------- +// +EXPORT_C CMCETestUIEngineOutSession::~CMCETestUIEngineOutSession() + { + delete iOutSession; + } + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::GetCommands +// ----------------------------------------------------------------------------- +// +const RPointerArray& + CMCETestUIEngineOutSession::GetCommandsL() + { + iCommands.ResetAndDestroy(); + + // Get base class commands + CMCETestUIEngineSession::GetCommandsL(); + + // Get own commands + TInt state = iOutSession->State(); + + switch( state ) + { + case CMceSession::EIdle: + iCommands.Append( new (ELeave) TMCETestUIEngineCmdEstablish( + iEngine, *this ) ); + iCommands.Append( new (ELeave) TMCETestUIEngineCmdEstablishWithValues( + iEngine, *this ) ); + iCommands.Append( new (ELeave) TMCETestUIEngineCmdFCSendSession( + iEngine, *this ) ); + + iCommands.Append( new (ELeave) + TMCETestUIEngineCmdDeleteSession( iEngine, *this ) ); + if(iSession->Type() == KMceSessionSecure) + { + iCommands.Append( new (ELeave) + TMCETestUIEngineCmdCurrentCryptoContext( iEngine, *this ) ); + iCommands.Append( new (ELeave) + TMCETestUIEngineCmdSupportedCryptoContext( iEngine, *this ) ); + iCommands.Append( new (ELeave) + TMCETestUIEngineCmdSetCryptoContext( iEngine, *this ) ); + } + break; + case CMceSession::EOffering: + iCommands.Append( new (ELeave) TMCETestUIEngineCmdCancelSession( + iEngine, *this ) ); + iCommands.Append( new (ELeave) TMCETestUIEngineCmdFCSendSession( + iEngine, *this ) ); + iCommands.Append( new (ELeave) + TMCETestUIEngineCmdDeleteSession( iEngine, *this ) ); + + iCommands.Append( new (ELeave) + TMCETestUIEngineCmdSendInfo( iEngine, *this ) ); + iCommands.Append( new (ELeave) + TMCETestUIEngineCmdDTMFInfo( iEngine, *this ) ); + iCommands.Append( new ( ELeave ) + TMCETestUIEngineCmdSendInfoResponse( iEngine, *this ) ); + + + + if(iSession->Type() == KMceSessionSecure) + { + iCommands.Append( new (ELeave) + TMCETestUIEngineCmdCurrentCryptoContext( iEngine, *this ) ); + iCommands.Append( new (ELeave) + TMCETestUIEngineCmdSupportedCryptoContext( iEngine, *this ) ); + } + + break; + case CMceSession::EEstablished: + if(VideoDirection() != EVideoNotSpesified) + { + if(iEngine.IsVideoEnabled()) + { + iCommands.Append( new (ELeave) + TMCETestUIEngineCmdDisableVideoSession( iEngine, *this ) ); + } + else + { + iCommands.Append( new (ELeave) + TMCETestUIEngineCmdEnableVideoSession( iEngine, *this ) ); + } + } + break; + default: + break; + } + + return iCommands; + } + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::Id +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CMCETestUIEngineOutSession::Id() const + { + return iId; + } + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::OutSession +// ----------------------------------------------------------------------------- +// +CMceOutSession& CMCETestUIEngineOutSession::OutSession() + { + return *iOutSession; + } + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::SessionParams +// ----------------------------------------------------------------------------- +// + +TBool CMCETestUIEngineOutSession::SessionParamsL(TSessionParams &aSessionParams, + TSessionType aSessionType) + { + return iEngine.SessionParamsL( aSessionParams,aSessionType ); + } + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::FillPoCSessionData +// ----------------------------------------------------------------------------- +// + +void CMCETestUIEngineOutSession::FillProfileRegistrar() + { + // trying to get profile registrar + if(iEngine.iOutSessionWithProfile) + { + TUriParser8 parser; + const TDesC8& aor = iProfile->Aor(); + parser.Parse( aor ) ; + CUri8* uri8 = CUri8::NewLC( parser ); + const TDesC8& registrar = uri8->Uri().Extract( EUriHost ) ; + + HBufC*registrar16 = HBufC16::NewLC( KRecipent().Length() + registrar.Length() ); + TPtr registrarPtr = registrar16->Des(); + registrarPtr.Copy( registrar ); + + iSessionParams.iRecipentAddress.Append(KRecipent) ; + iSessionParams.iRecipentAddress.Append(*registrar16) ; + + CleanupStack::PopAndDestroy( registrar16 ); + registrar16 = NULL; + + CleanupStack::PopAndDestroy( uri8 ); + uri8 = NULL; + } + else + { + iSessionParams.iRecipentAddress.Append(KRecipent) ; + } + + // profile registrar end ..... + } + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::FillPoCorigAddress +// ----------------------------------------------------------------------------- +// + +void CMCETestUIEngineOutSession::FillPoCOrigAddress() + { + + if(iEngine.IsFCSession()) + { + const TDesC8& aor = iProfile->Aor(); + HBufC*aor16 = HBufC16::NewLC( aor.Length() ); + TPtr aorPtr = aor16->Des(); + aorPtr.Copy(aor); + iSessionParams.originator.Append(*aor16) ; + CleanupStack::PopAndDestroy( aor16 ); + aor16 = NULL; + } + + } + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::FillVoIPSessionData +// ----------------------------------------------------------------------------- +// + +void CMCETestUIEngineOutSession::FillVoIPSessionData(CMceOutSession* outSession) + { + + // OUT STREAM + // create "audio out" stream first, puts audioOutStream to cleanupstack + CMceAudioStream* audioOutStream = CMceAudioStream::NewLC(); + + // create mic source + CMceMicSource* mic = CMceMicSource::NewLC(); + + // set source for "audio out" stream, in this case it's microphone + // there can be only one source at a time. + audioOutStream->SetSourceL( mic ); + + // pop mic from cleanupstack + CleanupStack::Pop( mic ); + + // create rtp sink for mic + CMceRtpSink* rtpSink = CMceRtpSink::NewL(); + CleanupStack::PushL( rtpSink ); + audioOutStream->AddSinkL( rtpSink ); + CleanupStack::Pop( rtpSink ); + + // IN STREAM + // create "audio in" stream + CMceAudioStream* audioInStream = CMceAudioStream::NewLC(); + + // create rtp source for "audio in" stream + CMceRtpSource* rtpSource = CMceRtpSource::NewLC( iEngine.iJitterBufSize, + iEngine.iJitterBufTreshold, 0 ); + audioInStream->SetSourceL( rtpSource ); + // pop rtp source from cleanupstack + CleanupStack::Pop( rtpSource ); + + // create speaker sink for "audio in" stream + CMceSpeakerSink* speaker = CMceSpeakerSink::NewLC(); + audioInStream->AddSinkL( speaker ); + // pop speaker from cleanupstack + CleanupStack::Pop( speaker ); + + // bind "audio out" stream to "audio in" stream + // audioInStream->BindL( audioOutStream ); + audioOutStream->BindL( audioInStream ); + // iSession->AddStreamL( audioInStream ); + outSession->AddStreamL( audioOutStream ); + + // modify QoS preconditions off + outSession->SetModifierL( KMcePreconditions, KMcePreconditionsNotUsed ); + + + // add codecs to audiostream + // some default voip values to be still added + + // set MMF priorities and preferences to codecs + // set MMF codec priorities for all codecs in both streams + + iEngine.SetMMFPriorityForCodecsL( audioInStream->Codecs(), + iEngine.iPriorityDownlink, + iEngine.iPrefDownlink ); + + iEngine.SetMMFPriorityForCodecsL( audioOutStream->Codecs(), + iEngine.iPriorityUplink, + iEngine.iPrefUplink ); + + // pop audioInStream from cleanupstack + CleanupStack::Pop( audioInStream ); + + // pop audioOutStream from cleanupstack + CleanupStack::Pop( audioOutStream ); + + + } +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::FillPoCSessionData +// ----------------------------------------------------------------------------- +// + +void CMCETestUIEngineOutSession::FillPoCSessionData(CMceOutSession* outSession) + { + iDirection = ESendRecv; + const TInt KStartLocalPort = 6688; + const TInt AMRDefOfferPTime = 160; + + // Maximum ptime + const TInt AMRDefOfferMaxPTime = 400; + + // Allowed bitrates + const TInt AMRDefOfferAllowedBitrates = KMceAllowedAmrNbBitrate475 | + KMceAllowedAmrNbBitrate515 | + KMceAllowedAmrNbBitrate590; + + // Bitrate + const TInt AMRDefOfferBitrate = KMceAmrNbBitrate515; + + // Codec mode + const TInt AMRDefOfferCodingMode = EMceOctetAligned; + + + CMceAudioStream* audioOutStream = NULL; + // audio in stream + CMceAudioStream* audioStreamIn = CMceAudioStream::NewLC(); + + TInt locPort( KStartLocalPort ); + locPort = locPort + ( 128 * 2 ); + + audioStreamIn->SetLocalMediaPortL( locPort ); + + CMceSpeakerSink* speakerSink = CMceSpeakerSink::NewLC(); + audioStreamIn->AddSinkL(speakerSink); + CleanupStack::Pop(); + + // TODO: + HBufC8* rtpSourceIdentity = KMCERtpSourceIdentity().AllocLC(); + CMceRtpSource* rtpSource = CMceRtpSource::NewLC( iEngine.iJitterBufSize, + iEngine.iJitterBufTreshold, + iEngine.iJitterBufTimeout, + rtpSourceIdentity); + audioStreamIn->SetSourceL(rtpSource); + //rtpSource->EnableInactivityTimerL(10000); + CleanupStack::Pop(); + CleanupStack::PopAndDestroy(rtpSourceIdentity); + + CMceAudioStream* audioStreamOut = CMceAudioStream::NewLC(); + HBufC8* rtpSinkIdentity = KMCERtpSinkIdentity().AllocLC(); + CMceRtpSink* rtpSink = CMceRtpSink::NewL( ETrue, rtpSinkIdentity); + audioStreamOut->AddSinkL(rtpSink); + CleanupStack::PopAndDestroy(rtpSinkIdentity); + + CMceMicSource* micSource = CMceMicSource::NewLC(); + audioStreamOut->SetSourceL(micSource); + micSource->DisableL(); + CleanupStack::Pop(); + + audioStreamIn->BindL(audioStreamOut); + CleanupStack::Pop(audioStreamOut); + // floor control + + outSession->AddStreamL( audioStreamIn ); + CleanupStack::Pop(audioStreamIn); + // + // TODO: Currently MMComms supports only the first codec of the stream + // + const RPointerArray& codecs = audioStreamIn->Codecs(); + + for( int i = 0; i < codecs.Count(); i++ ) + { + CMceAudioCodec* codec = codecs[i]; + + // Search for AMR codec and delete others + if( codec->SdpName() != KMceSDPNameAMR ) + { + audioStreamIn->RemoveCodecL( *codec ); + --i; + } + } + + if( codecs.Count() != 1 ) + { + User::Leave( KErrArgument ); + } + + CMceAmrCodec* amrcodec = ( CMceAmrCodec* ) codecs[0]; + + const RPointerArray& codecsOut = audioStreamOut->Codecs(); + CMceAmrCodec* amrcodecOut = (CMceAmrCodec*)codecsOut[0]; + + + // set prioirity for uplink + amrcodecOut->SetMMFPriorityL( iEngine.iPriorityUplink ); + amrcodecOut->SetMMFPriorityPreferenceL( iEngine.iPrefUplink ); + + // set prioirity for downlink + amrcodec->SetMMFPriorityL( iEngine.iPriorityDownlink ); + amrcodec->SetMMFPriorityPreferenceL( iEngine.iPrefDownlink ); + + // + // Set initial parameters for codec + // + // Allowed bitrates + amrcodec->SetAllowedBitrates( AMRDefOfferAllowedBitrates ); + + // Bitrate should be 5150 + amrcodec->SetBitrate( AMRDefOfferBitrate ); + + // AMR narrow band, sampling rate 8000 + amrcodec->SetSamplingFreq( KMceAmrNbSamplingFreq ); + + // Use bandwith effient coding + amrcodec->SetCodecMode( AMRDefOfferCodingMode ); + amrcodecOut->SetCodecMode( AMRDefOfferCodingMode ); + + // Default packet ratio is 8 AMR packets per one RTP packet + // -> ptime = 8 * 20 = 160. Lower value is not good with GPRS bearer + amrcodec->SetPTime(AMRDefOfferPTime ); + + // Allowable maximum ptime, 400 should be OK + amrcodec->SetMaxPTime( AMRDefOfferMaxPTime ); + + // 106 seems to be common payload type + amrcodec->SetPayloadType( 106 ); + + + // Disabled here due to audio server crash +// CMceRtpSink* rtpOutSink = (CMceRtpSink*) audioStreamOut->Sinks()[0]; +// rtpOutSink->DisableL(); + } + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::FillCustomSessionData +// ----------------------------------------------------------------------------- +// +void CMCETestUIEngineOutSession::FillCustomSessionData(CMceOutSession* outSession) + { + + // setmodifier for the session, by default preconditions are present, if no preconditions then setthis + if( iSessionParams.iNoPrecondtion) + { + outSession->SetModifierL(KMcePreconditions,KMcePreconditionsNotUsed); + } + outSession->SetServiceTypeL(iSessionParams.iServiceType); + switch (iSessionParams.index ) + { + case 0: + iDirection = ESendRecv; + break; + case 1: + iDirection = ESendOnly; + break; + case 2: + iDirection = ERecvOnly; + break; + default: + iDirection = ENotSpesified; + break; + } + + CMceFileSource* fileSource = NULL; + CMceAudioStream* audioOutStream = NULL; + CMceAudioStream* audioOutStreamLocal = NULL; + if ( iDirection != ENotSpesified ) + { + // Create outstream (== uplink) + + if ( iDirection == ESendOnly || + iDirection == ESendRecv ) + { + audioOutStream = CMceAudioStream::NewLC(); + CMceMicSource* mic = NULL; + + if(iSessionParams.sourceType) + { + fileSource = CMceFileSource::NewL(iEngine.MCEManager(), iSessionParams.sourceFile ); + CleanupStack::PushL( fileSource ); + audioOutStream->SetSourceL(fileSource); + CleanupStack::Pop( fileSource ); + } + else + { + mic = CMceMicSource::NewLC(); + audioOutStream->SetSourceL( mic ); + CleanupStack::Pop( mic ); + } + + + CMceRtpSink* rtpSink; + CMceSpeakerSink* speakerSink; + + if(iSessionParams.audioSinkType) + { + speakerSink = CMceSpeakerSink::NewLC(); + audioOutStream->AddSinkL( speakerSink ); + speakerSink->SetRoutingL( KMceAudioRoutePrivate ); + CleanupStack::Pop( speakerSink ); + } + else + { + HBufC8* rtpSinkIdentity = KMCERtpSinkIdentity().AllocLC(); + if(iEngine.iRtcpFlag) + { + rtpSink = CMceRtpSink::NewL(ETrue, rtpSinkIdentity); + CleanupStack::PushL(rtpSink); + } + else + { + rtpSink = CMceRtpSink::NewL( EFalse, rtpSinkIdentity ); + CleanupStack::PushL(rtpSink); + } + audioOutStream->AddSinkL( rtpSink ); + CleanupStack::Pop( rtpSink ); + CleanupStack::PopAndDestroy(rtpSinkIdentity); + } + + // Create stream for local playing of the audio + if ( fileSource && iEngine.iBundle ) + { + audioOutStreamLocal = CMceAudioStream::NewLC(); + audioOutStreamLocal->SetSourceL(fileSource); + speakerSink = 0; + speakerSink = CMceSpeakerSink::NewLC(); + audioOutStreamLocal->AddSinkL( speakerSink ); + CleanupStack::Pop( speakerSink ); + } + + if( iEngine.iSdp ) + { + CDesC8Array* array = new (ELeave) CDesC8ArrayFlat(3); + array->AppendL(_L8("a=OutgoingStream1UL:20\r\n")); + array->AppendL(_L8("a=OutgoingStream2UL:40\r\n")); + array->AppendL(_L8("b=AS:64\r\n")); + audioOutStream->SetMediaAttributeLinesL( array ); + + } + } + + // Create instream (== downlink) + CMceAudioStream* audioInStream = NULL; + + if ( iDirection == ERecvOnly || + iDirection == ESendRecv ) + { + audioInStream = CMceAudioStream::NewLC(); + HBufC8* rtpSourceIdentity = KMCERtpSourceIdentity().AllocLC(); + CMceRtpSource* rtpSource = CMceRtpSource::NewL( iEngine.iJitterBufSize, + iEngine.iJitterBufTreshold, + iEngine.iJitterBufTimeout, + rtpSourceIdentity); + CleanupStack::PushL( rtpSource ); + audioInStream->SetSourceL( rtpSource ); + CleanupStack::Pop( rtpSource ); + CleanupStack::PopAndDestroy(rtpSourceIdentity); + + CMceSpeakerSink* speaker = CMceSpeakerSink::NewLC(); + speaker->SetRoutingL( KMceAudioRoutePrivate ); + audioInStream->AddSinkL( speaker ); + CleanupStack::Pop( speaker ); + + if( iEngine.iSdp ) + { + CDesC8Array* array = new (ELeave) CDesC8ArrayFlat(3); + array->AppendL(_L8("a=OutgoingStream1DL:20\r\n")); + array->AppendL(_L8("a=BoundStream:40\r\n")); + array->AppendL(_L8("b=AS:64\r\n")); + audioInStream->SetMediaAttributeLinesL( array ); + } + + } + + // Bound streams + if ( iDirection == ESendRecv ) + { + audioOutStream->BindL( audioInStream ); + + if ( audioInStream ) + { + CleanupStack::Pop( audioInStream ); + } + } + + // Add streams to OutSession + if ( iDirection != ERecvOnly ) + { + if ( audioOutStreamLocal ) + { + outSession->AddStreamL( audioOutStreamLocal ); + CleanupStack::Pop( audioOutStreamLocal ); + + iEngine.SetMMFPriorityForCodecsL( audioOutStreamLocal->Codecs(), + iEngine.iPriorityUplink, + iEngine.iPrefUplink ); + } + + outSession->AddStreamL( audioOutStream ); + CleanupStack::Pop( audioOutStream ); + + + iEngine.SetMMFPriorityForCodecsL( audioOutStream->Codecs(), + iEngine.iPriorityUplink, + iEngine.iPrefUplink ); + + if ( audioInStream ) + { + iEngine.SetMMFPriorityForCodecsL( audioInStream->Codecs(), + iEngine.iPriorityDownlink, + iEngine.iPrefDownlink ); + } + } + else + { + outSession->AddStreamL( audioInStream ); + CleanupStack::Pop( audioInStream ); + + iEngine.SetMMFPriorityForCodecsL( audioInStream->Codecs(), + iEngine.iPriorityDownlink, + iEngine.iPrefDownlink ); + } + + } + switch (iSessionParams.videoIndex ) + { + case 0: + iVideoDirection = EVideoSendRecv; + break; + case 1: + iVideoDirection = EVideoSendOnly; + break; + case 2: + iVideoDirection = EVideoRecvOnly; + break; + default: + iVideoDirection = EVideoNotSpesified; + break; + } + + CMceVideoStream* videoOutStreamRTP = NULL; + CMceVideoStream* videoOutStreamDisplay = NULL; + CMceVideoStream* videoOutStreamFile = NULL; + CMceVideoStream* vidStreamLocal = NULL; + CMceCameraSource* cam =NULL; + CMceFileSource* videoFileSource = NULL; + + if ( iVideoDirection != EVideoNotSpesified ) + { + // Create outstream (== uplink) + + + if ( iVideoDirection == EVideoSendOnly || + iVideoDirection == EVideoSendRecv ) + { + // UL stream present + CMceRtpSink* rtpSink = NULL; + CMceDisplaySink* dispSink = NULL; + CMceFileSink* fileSink = NULL; + + if(iSessionParams.videoSinkDisplay) + { + dispSink = CMceDisplaySink::NewLC( iEngine.MCEManager()); + // TRect viewFinder(0, 83, 352, 378); + TRect viewFinder(32, 88, 208, 232); + // TRect viewFinder(iEngine.GetRect()); + dispSink->SetDisplayRectL( viewFinder ); + videoOutStreamDisplay = CMceVideoStream::NewL(); + CleanupStack::Pop( dispSink ); + CleanupStack::PushL( videoOutStreamDisplay ); + videoOutStreamDisplay->AddSinkL( dispSink ); + if(iSessionParams.sourceType) + { + //check for filesource if it is already there --- start + if(fileSource) + { + videoOutStreamDisplay->SetSourceL( fileSource ); + } + else + { + fileSource = CMceFileSource::NewL(iEngine.MCEManager(), iSessionParams.sourceFile ); + CleanupStack::PushL( fileSource ); + videoOutStreamDisplay->SetSourceL(fileSource); + CleanupStack::Pop( fileSource ); + } + } + else + { + cam = CMceCameraSource::NewL(iEngine.MCEManager()); + CleanupStack::PushL( cam ); + videoOutStreamDisplay->SetSourceL( cam ); + CleanupStack::Pop( cam ); + } + + outSession->AddStreamL( videoOutStreamDisplay ); + CleanupStack::Pop( videoOutStreamDisplay ); + + iEngine.SetMMFPriorityForCodecsL( videoOutStreamDisplay->Codecs(), + iEngine.iPriorityUplink, + iEngine.iPrefUplink ); + } + + if(iSessionParams.videoSinkFile) + { + fileSink = CMceFileSink::NewLC( iSessionParams.sinkFile); + videoOutStreamFile = CMceVideoStream::NewL(); + CleanupStack::Pop( fileSink ); + CleanupStack::PushL( videoOutStreamFile ); + videoOutStreamFile->AddSinkL( fileSink ); + if(iSessionParams.sourceType) + { + //check for filesource if it is already there --- start + if(fileSource) + { + videoOutStreamFile->SetSourceL( fileSource ); + } + else + { + fileSource = CMceFileSource::NewL(iEngine.MCEManager(), iSessionParams.sourceFile ); + CleanupStack::PushL( fileSource ); + videoOutStreamFile->SetSourceL(fileSource); + CleanupStack::Pop( fileSource ); + } + } + else + { + // need to check for camera ????? + if(cam) + { + videoOutStreamFile->SetSourceL( cam ); + } + else + { + cam = CMceCameraSource::NewL(iEngine.MCEManager()); + CleanupStack::PushL( cam ); + videoOutStreamFile->SetSourceL( cam ); + CleanupStack::Pop( cam ); + } + + } + CleanupStack::Pop( videoOutStreamFile ); + outSession->AddStreamL( videoOutStreamFile ); + + AdjustVideoCodecsL( videoOutStreamFile->Codecs() ); + } + if( iSessionParams.videoSinkRtp ) + { + + videoOutStreamRTP = CMceVideoStream::NewL(); + CleanupStack::PushL( videoOutStreamRTP ); + + HBufC8* rtpSinkIdentity = KMCERtpSinkIdentity().AllocLC(); + if(iEngine.iRtcpFlag) + { + rtpSink = CMceRtpSink::NewL(ETrue,rtpSinkIdentity ); + CleanupStack::PushL( rtpSink ); + } + else + { + rtpSink = CMceRtpSink::NewL(EFalse, rtpSinkIdentity); + CleanupStack::PushL( rtpSink ); + } + + videoOutStreamRTP->AddSinkL( rtpSink ); + CleanupStack::Pop( rtpSink ); + CleanupStack::PopAndDestroy(rtpSinkIdentity); + if(iSessionParams.sourceType) + { + //check for filesource if it is already there --- start + if(fileSource) + { + videoOutStreamRTP->SetSourceL( fileSource ); + } + else + { + fileSource = CMceFileSource::NewL(iEngine.MCEManager(), iSessionParams.sourceFile ); + CleanupStack::PushL( fileSource ); + videoOutStreamRTP->SetSourceL(fileSource); + CleanupStack::Pop( fileSource ); + } + } + else + { + // need to check for camera ????? + if(cam) + { + videoOutStreamRTP->SetSourceL( cam ); + } + else + { + cam = CMceCameraSource::NewL(iEngine.MCEManager()); + CleanupStack::PushL( cam ); + videoOutStreamRTP->SetSourceL( cam ); + CleanupStack::Pop( cam ); + } + + } + } + + } // uplink over + + // Create instream (== downlink) + CMceVideoStream* videoInStreamRTP = NULL; + + if ( iVideoDirection == EVideoRecvOnly || + iVideoDirection == EVideoSendRecv ) + { + videoInStreamRTP = CMceVideoStream::NewLC(); + HBufC8* rtpSourceIdentity = KMCERtpSourceIdentity().AllocLC(); + + TInt jitbufSize( iEngine.iJitterBufSize ); + TInt jitbufThreshold( iEngine.iJitterBufTreshold ); + TInt jitbufTimeout( iEngine.iJitterBufTimeout ); + iEngine.GetJitterBufferValues( + videoInStreamRTP, jitbufSize, jitbufThreshold, jitbufTimeout, ETrue ); + + CMceRtpSource* rtpSource = CMceRtpSource::NewLC( jitbufSize, + jitbufThreshold, + jitbufTimeout, + rtpSourceIdentity); + videoInStreamRTP->SetSourceL( rtpSource ); + CleanupStack::Pop( rtpSource ); + CleanupStack::PopAndDestroy(rtpSourceIdentity); + CMceDisplaySink* display = CMceDisplaySink::NewLC(iEngine.MCEManager()); + videoInStreamRTP->AddSinkL( display ); + // + if( iEngine.iSdp ) + { + CDesC8Array* array = new (ELeave) CDesC8ArrayFlat(1); + array->AppendL(_L8("b=AS:64\r\n")); + videoInStreamRTP->SetMediaAttributeLinesL( array ); + } + + // + // TRect disp(32, 88, 208, 232); + TRect disp(iEngine.GetRect()); + display->SetDisplayRectL( disp ); + // display->DisableL(); + CleanupStack::Pop( display ); + } + + // Bound streams + if ( iVideoDirection == ESendRecv && + videoOutStreamRTP ) + { + videoOutStreamRTP->BindL( videoInStreamRTP ); + + if ( videoInStreamRTP ) + { + CleanupStack::Pop( videoInStreamRTP ); + } + CleanupStack::Pop( videoOutStreamRTP ); + outSession->AddStreamL( videoOutStreamRTP ); + + AdjustVideoCodecsL( videoOutStreamRTP->Codecs() ); + } + + else // no bound streams present, either UL or DL + { + if( iVideoDirection == EVideoRecvOnly ) // DL present + { + CleanupStack::Pop( videoInStreamRTP ); + outSession->AddStreamL( videoInStreamRTP ); + } + else if ( videoOutStreamRTP ) // RTP UL if present + { + CleanupStack::Pop( videoOutStreamRTP ); + outSession->AddStreamL( videoOutStreamRTP ); + + AdjustVideoCodecsL( videoOutStreamRTP->Codecs() ); + + iEngine.SetMMFPriorityForCodecsL( videoOutStreamRTP->Codecs(), + iEngine.iPriorityUplink, + iEngine.iPrefUplink ); + } + } + } + if( iEngine.iBundle /*iSessionParams.iBundle*/ ) + { + if( audioOutStream && videoOutStreamDisplay && + iSessionParams.sourceType ) + { + // audio and video from file present, bundle + CMceStreamBundle* bundle = CMceStreamBundle::NewLC( CMceStreamBundle::ELS ); + // bundle->AddStreamL( *audioOutStream ); + bundle->AddStreamL( *videoOutStreamDisplay ); + if ( audioOutStreamLocal ) + { + bundle->AddStreamL( *audioOutStreamLocal ); + } + CleanupStack::Pop( bundle ); + outSession->AddBundleL( bundle ); + } + } + + } + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::Fill2WayVideoSessionDataL +// ----------------------------------------------------------------------------- +// +void CMCETestUIEngineOutSession::Fill2WayVideoSessionDataL(CMceOutSession* aOutSession) + { + // Video + // + + aOutSession->SetModifierL( KMcePreconditions, KMcePreconditionsNotUsed ); + + // Create video uplink + // + CMceVideoStream* videoOutStream = CMceVideoStream::NewL(); + CleanupStack::PushL( videoOutStream ); + + CMceRtpSink* rtpSink = CMceRtpSink::NewL( ETrue ); + CleanupStack::PushL( rtpSink ); + videoOutStream->AddSinkL( rtpSink ); + CleanupStack::Pop( rtpSink ); + + CMceCameraSource* cam = CMceCameraSource::NewL( iEngine.MCEManager() ); + CleanupStack::PushL( cam ); + + if ( iSessionParams.iCameraSetting == TSessionParams::EMceCameraSecondary ) + { + if ( cam->CamerasAvailable() > 1 ) + { + cam->SetCameraIndexL( 1 ); + } + } + + videoOutStream->SetSourceL( cam ); + CleanupStack::Pop( cam ); + + CMceVideoStream* videoLocalStream = NULL; + if ( iSessionParams.videoSinkDisplay == TSessionParams::EMceViewFinderEnabled ) + { + videoLocalStream = CMceVideoStream::NewL(); + CleanupStack::PushL( videoLocalStream ); + CMceDisplaySink* localDispSink = CMceDisplaySink::NewLC( iEngine.MCEManager() ); + + TRect localDisplayRect(0, 0, 36, 44); + AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EStatusPane, localDisplayRect ); + localDispSink->SetDisplayRectL( localDisplayRect ); + localDispSink->SetPriorityL( ECoeWinPriorityAlwaysAtFront ); + videoLocalStream->AddSinkL( localDispSink ); + CleanupStack::Pop( localDispSink ); + + videoLocalStream->SetSourceL( cam ); + + aOutSession->AddStreamL( videoLocalStream ); + CleanupStack::Pop( videoLocalStream ); + } + + // Create video downlink + // + CMceVideoStream* videoInStream = CMceVideoStream::NewL(); + CleanupStack::PushL( videoInStream ); + + CMceDisplaySink* dispSink = CMceDisplaySink::NewLC( iEngine.MCEManager()); + + TRect displayRect(32, 88, 208, 232); + AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, displayRect ); + dispSink->SetDisplayRectL( displayRect ); + videoInStream->AddSinkL( dispSink ); + CleanupStack::Pop( dispSink ); + + TInt jitbufSize( iEngine.iJitterBufSize ); + TInt jitbufThreshold( iEngine.iJitterBufTreshold ); + TInt jitbufTimeout( iEngine.iJitterBufTimeout ); + + iEngine.GetJitterBufferValues( + videoInStream, jitbufSize, jitbufThreshold, jitbufTimeout, ETrue ); + + CMceRtpSource* rtpSource = CMceRtpSource::NewLC( jitbufSize, + jitbufThreshold, + jitbufTimeout ); + videoInStream->SetSourceL( rtpSource ); + CleanupStack::Pop( rtpSource ); + + // Modify codecs and make sendrecv session + // + videoOutStream->BindL( videoInStream ); + CleanupStack::Pop( videoInStream ); + + aOutSession->AddStreamL( videoOutStream ); + CleanupStack::Pop( videoOutStream ); + + if ( iSessionParams.iVideoCodec == TSessionParams::EMceCodecSingle || + iSessionParams.iVideoCodec == TSessionParams::EMceCodecMultipleModes ) + { + // Remove all other codecs than first one + // + const RPointerArray& videoCodecs = + videoOutStream->Codecs(); + + for ( TInt i = videoCodecs.Count() - 1; i > 0; i-- ) + { + videoOutStream->RemoveCodecL( *videoCodecs[ i ] ); + } + + if ( videoLocalStream ) + { + const RPointerArray& videoCodecs2 = + videoLocalStream->Codecs(); + + for ( TInt i = videoCodecs2.Count() - 1; i > 0; i-- ) + { + videoLocalStream->RemoveCodecL( *videoCodecs2[ i ] ); + } + } + } + + if ( iSessionParams.iVideoCodec == TSessionParams::EMceCodecMultipleModes ) + { + // Currently make only multiple modes offer for AVC + CMceVideoCodec* defaultAvcCodec = NULL; + const RPointerArray& videoCodecs = + videoOutStream->Codecs(); + for ( TInt i = 0; i < videoCodecs.Count(); i++ ) + { + if ( videoCodecs[ i ]->SdpName().CompareF( KMceSDPNameH264 ) == 0 ) + { + defaultAvcCodec = videoCodecs[ i ]; + } + } + if ( defaultAvcCodec ) + { + CMceVideoCodec* otherModeAvcCodec = defaultAvcCodec->CloneL(); + CleanupStack::PushL( otherModeAvcCodec ); + TInt codecMode = defaultAvcCodec->CodecMode(); + TInt payloadType = defaultAvcCodec->PayloadType(); + payloadType++; + if ( codecMode == KMceAvcModeSingleNal ) + { + codecMode = KMceAvcModeNonInterleaved; + } + else + { + codecMode = KMceAvcModeSingleNal; + } + User::LeaveIfError( otherModeAvcCodec->SetCodecMode( codecMode ) ); + User::LeaveIfError( otherModeAvcCodec->SetPayloadType( payloadType ) ); + + videoOutStream->AddCodecL( otherModeAvcCodec ); + CleanupStack::Pop( otherModeAvcCodec ); + + CMceVideoCodec* otherModeAvcCodec2 = otherModeAvcCodec->CloneL(); + CleanupStack::PushL( otherModeAvcCodec2 ); + videoInStream->AddCodecL( otherModeAvcCodec2 ); + CleanupStack::Pop( otherModeAvcCodec2 ); + + if ( videoLocalStream ) + { + CMceVideoCodec* otherModeAvcCodec3 = otherModeAvcCodec->CloneL(); + CleanupStack::PushL( otherModeAvcCodec3 ); + videoLocalStream->AddCodecL( otherModeAvcCodec3 ); + CleanupStack::Pop( otherModeAvcCodec3 ); + } + } + } + + AdjustVideoCodecsL( videoOutStream->Codecs() ); + + // Audio + // + if ( iSessionParams.iAudioCodec != TSessionParams::EMceCodecNone ) + { + // Create audio uplink + // + CMceAudioStream* audioStreamOut = CMceAudioStream::NewLC(); + CMceRtpSink* rtpSink = CMceRtpSink::NewL( ETrue ); + audioStreamOut->AddSinkL( rtpSink ); + + CMceMicSource* micSource = CMceMicSource::NewLC(); + audioStreamOut->SetSourceL( micSource ); + CleanupStack::Pop(); + + // Create audio downlink + // + CMceAudioStream* audioStreamIn = CMceAudioStream::NewLC(); + + TInt jitbufSize2( iEngine.iJitterBufSize ); + TInt jitbufThreshold2( iEngine.iJitterBufTreshold ); + TInt jitbufTimeout2( iEngine.iJitterBufTimeout ); + iEngine.GetJitterBufferValues( + audioStreamIn, jitbufSize2, jitbufThreshold2, jitbufTimeout2, ETrue ); + + CMceRtpSource* rtpSource = CMceRtpSource::NewLC( jitbufSize2, + jitbufThreshold2, + jitbufTimeout2 ); + audioStreamIn->SetSourceL( rtpSource ); + CleanupStack::Pop(); + + CMceSpeakerSink* speakerSink = CMceSpeakerSink::NewLC(); + speakerSink->SetRoutingL( KMceAudioRoutePrivate ); + audioStreamIn->AddSinkL( speakerSink ); + CleanupStack::Pop(); + + // Make them sendrecv + // + audioStreamOut->BindL( audioStreamIn ); + CleanupStack::Pop( audioStreamIn ); + + aOutSession->AddStreamL( audioStreamOut ); + CleanupStack::Pop( audioStreamOut ); + + iEngine.SetMMFPriorityForCodecsL( audioStreamOut->Codecs(), + iEngine.iPriorityUplink, + iEngine.iPrefUplink ); + + iEngine.SetMMFPriorityForCodecsL( audioStreamIn->Codecs(), + iEngine.iPriorityDownlink, + iEngine.iPrefDownlink ); + + if ( iSessionParams.iAudioCodec == TSessionParams::EMceCodecSingle ) + { + const TDesC8& singleCodec = KMceSDPNamePCMU(); + const RPointerArray& audioCodecs = audioStreamOut->Codecs(); + for( int i = 0; i < audioCodecs.Count(); i++ ) + { + CMceAudioCodec* codec = audioCodecs[i]; + + // Search for AMR codec and delete others + if ( codec->SdpName().CompareF( singleCodec ) != 0 ) + { + audioStreamOut->RemoveCodecL( *codec ); + --i; + } + } + + __ASSERT_ALWAYS( audioCodecs.Count() == 1, User::Leave( KErrArgument ) ); + } + } + + } + +// ----------------------------------------------------------------------------- +// CMCETestUIEngineOutSession::GetVideoCodec +// ----------------------------------------------------------------------------- +// +CMceVideoCodec* CMCETestUIEngineOutSession::GetVideoCodec( + CMceVideoStream& aStream, const TDesC8& aSdpName ) + { + const RPointerArray& videoCodecs = aStream.Codecs(); + for ( TInt i = 0; i < videoCodecs.Count(); i++ ) + { + if ( videoCodecs[ i ]->SdpName().CompareF( aSdpName ) == 0 ) + { + return videoCodecs[ i ]; + } + } + return NULL; + } +