/*

* 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 "TCmdAddVideoStream.h"

#include "CTcMCEContext.h"

#include <badesca.h>

#include <MceInSession.h>

#include <MCEVideoStream.h>

#include <mcecamerasource.h>

#include <MceRtpSink.h>

#include <MceRtpSource.h>

#include <mcedisplaysink.h>

#include <MCEVideoCodec.h>

#include <mceh263codec.h>

#include <mcefilesource.h>

void TCmdAddVideoStream::ExecuteL()

	{	

	// ---------- Setup --------------------------------------------------------

	// Get session

	CMceSession* session = reinterpret_cast<CMceSession*>

		(GetObjectForIdL(KSessionId, ETrue));	

	// Get existing stream

	CMceMediaStream* mainStream = reinterpret_cast<CMceMediaStream*>

		(GetObjectForIdL(KStreamId, EFalse));	

	//source path for audiofile

	TPtrC8 pathAudioFile = ExtractTextL( KParamAudioFileSource, EFalse );

	//get path for media file sink

	TPtrC8 mediaFileSink = ExtractTextL( KParamMediaFileSink, EFalse );

	// ---------- Execution ----------------------------------------------------

	CMceVideoStream* videoStream = CMceVideoStream::NewLC();

	// Add source

	TPtrC8 source = ExtractTextL( KParamSource, EFalse );

	if (source == KValueSourceRTP )

		{

		CMceRtpSource* rtpSource = CMceRtpSource::NewLC();

		videoStream->SetSourceL(rtpSource);

		CleanupStack::Pop(rtpSource);			

		}

	else if (source == KValueSourceCamera )

		{

		CMceCameraSource* camera = CMceCameraSource::NewLC( iContext.MCEManager() );

		videoStream->SetSourceL(camera);	

		CleanupStack::Pop(camera);

		}

	else if (pathAudioFile.Compare( KNullDesC8 ) != 0)

		{

		// If source path was defined use the file audio specified in path

		iSessionHelper.SetMediaFileSourceL( iContext.MCEManager(), *videoStream, 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(EFalse);

				CleanupStack::PushL(rtpSink);

				videoStream->AddSinkL(rtpSink);

				CleanupStack::Pop(rtpSink);

				}

			else if ( (*sinks)[i] == KValueSinkSpeaker )

				{

				CMceDisplaySink* display = CMceDisplaySink::NewLC( iContext.MCEManager() );	

				videoStream->AddSinkL(display);

				CleanupStack::Pop(display);				

				}

			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() == KMceVideo )

						{

						//use the same source which was used for outgoing video stream	

						if( tmpStream->Source()->Type() != KMceRTPSource )

							{

							videoStream->SetSourceL( tmpStream->Source() );

							}

						else

							{

							if( tmpStream->BoundStream() )

								if( tmpStream->BoundStreamL().Source()->Type() != KMceRTPSource )

									videoStream->SetSourceL(tmpStream->BoundStreamL().Source());

							}			

						break;	//only one file sink can be added for testing

						}			        	

			        }

				if( mediaFileSink.Compare( KNullDesC8 ) != 0 )

					{

					iSessionHelper.SetMediaFileSinkL(*videoStream, mediaFileSink);

					}

				else

					{

					iSessionHelper.SetMediaFileSinkL(*videoStream, TPtrC8( KTestAudioFileName ));

					}

				session->AddStreamL(videoStream);

				}

	        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<CMceVideoCodec>& streamCodecs = 

			    videoStream->Codecs();

			if ( (*codecs)[0] == KValueCodecNone )

				{

			    // Remove all codecs from stream

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

                    {

                    // No implementation yet in MMCE

                    videoStream->RemoveCodecL( *(streamCodecs[i]) );

                    }

				}

			if ( (*codecs)[0] != KValueCodecNone &&

	 		   	 (*codecs)[0] != KValueCodecAll )

				{	

				for (TInt i = 0; i < codecs->Count(); i++ )

					{

					videoStream->AddCodecL( 

					    GetVideoCodecCloneL( (*codecs)[i] ) );

					}

				}

			}

		CleanupStack::PopAndDestroy( codecs );

		}

	// Add streams

	if (mainStream)

		{

		mainStream->BindL( videoStream );

		//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( videoStream );

	// ---------- Response creation --------------------------------------------

	AddIdResponseL(KSessionId, session); // uses CleanupStack internally

	AddIdResponseL(KStreamId, *videoStream); 

	}

TBool TCmdAddVideoStream::Match( const TTcIdentifier& aId )

	{

	return TTcMceCommandBase::Match( aId, _L8("AddVideoStream") );

	}

TTcCommandBase* TCmdAddVideoStream::CreateL( MTcTestContext& aContext )

	{

	return new( ELeave ) TCmdAddVideoStream( aContext );

	}

CMceVideoCodec* TCmdAddVideoStream::GetVideoCodecCloneL( const TDesC8& aParamCodecName )

    {

    const RPointerArray<const CMceVideoCodec>& managerVideoCodecs =

        iContext.MCEManager().SupportedVideoCodecs();

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

        {

        const CMceVideoCodec* managerVideoCodec = managerVideoCodecs[i];

        if ( managerVideoCodec->SdpName() == aParamCodecName )

            {

            return managerVideoCodec->CloneL();

            }

        }

    // If the requested codec is not supported

    User::Leave( KErrNotSupported );

    return NULL; // To keep compiler happy

    }