/*
* 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: Implementation
*
*/
#include "MCEConstants.h"
#include "TCmdAddAudioStream.h"
#include "CTcMCEContext.h"
#include <badesca.h>
#include <MceInSession.h>
#include <MCEAudioStream.h>
#include <MCEMicSource.h>
#include <MceRtpSink.h>
#include <MceRtpSource.h>
#include <MCESpeakerSink.h>
#include <MCEAudioCodec.h>
#include <MCEAMRCodec.h>
#include <mcefilesource.h>
void TCmdAddAudioStream::ExecuteL()
{
// ---------- Setup --------------------------------------------------------
// Get session
CMceSession* session = reinterpret_cast<CMceSession*>
(GetObjectForIdL(KSessionId, ETrue));
// Get existing stream
CMceMediaStream* mainStream = reinterpret_cast<CMceMediaStream*>
(GetObjectForIdL(KStreamId, EFalse));
TBool suppressRtcp = ExtractBooleanL( KParamSuppressRtcp, EFalse );
//source path for audiofile
TPtrC8 pathAudioFile = ExtractTextL( KParamAudioFileSource, EFalse );
//get path for media file sink
TPtrC8 mediaFileSink = ExtractTextL( KParamMediaFileSink, EFalse );
// ---------- Execution ----------------------------------------------------
CMceAudioStream* audioStream = CMceAudioStream::NewLC();
// Add source
TPtrC8 source = ExtractTextL( KParamSource, EFalse );
if (source == KValueSourceRTP )
{
CMceRtpSource* rtpSource = CMceRtpSource::NewLC();
audioStream->SetSourceL(rtpSource);
CleanupStack::Pop(rtpSource);
}
else if (source == KValueSourceMic )
{
CMceMicSource* mic = CMceMicSource::NewLC();
audioStream->SetSourceL(mic);
CleanupStack::Pop(mic);
}
else if (pathAudioFile.Compare( KNullDesC8 ) != 0)
{
// If source path was defined use the file audio specified in path
iSessionHelper.SetMediaFileSourceL( iContext.MCEManager(), *audioStream, pathAudioFile );
}
else
{
if( mediaFileSink.Compare( KNullDesC8 ) == 0 )
User::Leave( KErrNotSupported );
}
// Add sinks
CDesC8Array* sinks = ExtractArrayL( KParamSinks, EFalse );
if ( sinks )
{
CleanupStack::PushL( sinks );
for ( TInt i = 0; i < sinks->Count(); i++ )
{
if ( (*sinks)[i] == KValueSinkRTP )
{
//CMceRtpSink* rtpSink = CMceRtpSink::NewLC();
//enable all RtpSink with RTCP
CMceRtpSink* rtpSink = CMceRtpSink::NewL(suppressRtcp);
CleanupStack::PushL(rtpSink);
audioStream->AddSinkL(rtpSink);
CleanupStack::Pop(rtpSink);
}
else if ( (*sinks)[i] == KValueSinkSpeaker )
{
CMceSpeakerSink* speaker = CMceSpeakerSink::NewLC();
audioStream->AddSinkL(speaker);
CleanupStack::Pop(speaker);
}
else if ( (*sinks)[i] == KValueSinkFile )
{
const RPointerArray<CMceMediaStream>& streams = session->Streams();
for ( TInt i = 0; i < streams.Count(); ++i )
{
CMceMediaStream* tmpStream;
tmpStream = streams[i];
if ( tmpStream->Type() == KMceAudio )
{
//use the same source which was used for outgoing audio stream
if( tmpStream->Source()->Type() != KMceRTPSource )
{
audioStream->SetSourceL( tmpStream->Source() );
}
else
{
if(tmpStream->BoundStream())
if( tmpStream->BoundStreamL().Source()->Type() != KMceRTPSource )
audioStream->SetSourceL(tmpStream->BoundStreamL().Source());
}
break;
}
}
if( mediaFileSink.Compare( KNullDesC8 ) != 0 )
{
iSessionHelper.SetMediaFileSinkL(*audioStream, mediaFileSink);
}
else
{
iSessionHelper.SetMediaFileSinkL(*audioStream, TPtrC8( KTestAudioFileName ));
}
session->AddStreamL(audioStream);
}
else
{
User::Leave( KErrNotSupported );
}
}
CleanupStack::PopAndDestroy( sinks );
}
// Modify codecs
CDesC8Array* codecs = ExtractArrayL( KParamCodecs, EFalse );
if ( codecs )
{
CleanupStack::PushL( codecs );
if ( codecs->Count() > 0)
{
const RPointerArray<CMceAudioCodec>& streamCodecs =
audioStream->Codecs();
if ( (*codecs)[0] == KValueCodecNone )
{
// Remove all codecs from stream
for (TInt i = 0; i < streamCodecs.Count(); i++ )
{
// No implementation yet in MMCE
audioStream->RemoveCodecL( *(streamCodecs[i]) );
}
}
if ( (*codecs)[0] != KValueCodecNone &&
(*codecs)[0] != KValueCodecAll )
{
for (TInt i = 0; i < codecs->Count(); i++ )
{
audioStream->AddCodecL(
GetAudioCodecCloneL( (*codecs)[i] ) );
}
}
}
CleanupStack::PopAndDestroy( codecs );
}
// Add streams
if (mainStream)
{
mainStream->BindL( audioStream );
//if there are no codecs in the stream already, all the codecs will be
//added to stream by mce.
//Note: streams needs to be bound before adding stream to session
session->AddStreamL( mainStream );
}
else
{
//NOOP
}
CleanupStack::Pop( audioStream );
// ---------- Response creation --------------------------------------------
AddIdResponseL(KSessionId, session); // uses CleanupStack internally
AddIdResponseL(KStreamId, *audioStream);
}
TBool TCmdAddAudioStream::Match( const TTcIdentifier& aId )
{
return TTcMceCommandBase::Match( aId, _L8("AddAudioStream") );
}
TTcCommandBase* TCmdAddAudioStream::CreateL( MTcTestContext& aContext )
{
return new( ELeave ) TCmdAddAudioStream( aContext );
}
CMceAudioCodec* TCmdAddAudioStream::GetAudioCodecCloneL( const TDesC8& aParamCodecName )
{
const RPointerArray<const CMceAudioCodec>& managerAudioCodecs =
iContext.MCEManager().SupportedAudioCodecs();
for ( TInt i = 0; i < managerAudioCodecs.Count(); i++ )
{
const CMceAudioCodec* managerAudioCodec = managerAudioCodecs[i];
if ( managerAudioCodec->SdpName() == aParamCodecName )
{
return managerAudioCodec->CloneL();
}
}
// If the requested codec is not supported
User::Leave( KErrNotSupported );
return NULL; // To keep compiler happy
}