/*

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

*

*/

#include <MCESession.h>

#include <MCEMediaStream.h>

#include <MCEVideoStream.h>

#include <MCEMediaSource.h>

#include <MCEMicSource.h>

#include <MCEMediaSink.h>

#include <MCERtpSink.h>

#include <MCERtpSource.h>

#include <MCESpeakerSink.h>

#include <MCEVideoCodec.h>

#include "MCETestUIEngineConstants.h"

#include "CMCETestUIEngineVideoStream.h"

#include "CMCETestUIEngineVideoCodec.h"

#include "CMCETestUIEngineVideoSink.h"

#include "CMCETestUIEngineVideoSource.h"

#include "TMCETestUIEngineCmdBase.h"

#include "TMCETestUIEngineCmdEnableStream.h"

#include "TMCETestUIEngineCmdDisableStream.h"

#include "TMCETestUIEngineCmdRemoveStream.h"

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CMCETestUIEngineOutSession::NewL()

// -----------------------------------------------------------------------------

//

CMCETestUIEngineVideoStream* CMCETestUIEngineVideoStream::NewL(

    CMCETestUIEngine& aEngine, 

    CMceVideoStream& aVideoStream )

    {

    CMCETestUIEngineVideoStream* self = 

        new( ELeave )CMCETestUIEngineVideoStream( aEngine, aVideoStream );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;  

    }

// -----------------------------------------------------------------------------

// CMCETestUIEngineVideoStream::CMCETestUIEngineVideoStream

// -----------------------------------------------------------------------------

//

CMCETestUIEngineVideoStream::CMCETestUIEngineVideoStream( 

                CMCETestUIEngine& aEngine,

                CMceVideoStream& aVideoStream )

    : iEngine( aEngine ),

      iVideoStream( aVideoStream ),

      iOneTimeRTCPFlag(1),

      iVideoDirection( CMCETestUIEngineVideoStream::ENotSpesified )

    {

    }

// -----------------------------------------------------------------------------

// CMCETestUIEngineVideoStream::ConstructL()

// -----------------------------------------------------------------------------

//

void CMCETestUIEngineVideoStream::ConstructL()

    {

    SolveVideoDirection();

    }

// -----------------------------------------------------------------------------

// CMCETestUIEngineVideoStream::~CMCETestUIEngineVideoStream

// -----------------------------------------------------------------------------

//

EXPORT_C CMCETestUIEngineVideoStream::~CMCETestUIEngineVideoStream()

    {

    iCommands.ResetAndDestroy();

    iSources.ResetAndDestroy();

    iSinks.ResetAndDestroy();

    iCodecs.ResetAndDestroy();

    }

// -----------------------------------------------------------------------------

// CMCETestUIEngineVideoStream::GetCommands

// -----------------------------------------------------------------------------

//

const RPointerArray<TMCETestUIEngineCmdBase>& 

    CMCETestUIEngineVideoStream::GetCommandsL()

    {	

    iCommands.ResetAndDestroy();

    if ( iVideoStream.IsEnabled() )

        {

        iCommands.Append( new( ELeave )TMCETestUIEngineCmdDisableVideoStream( 

            iEngine, *this ) );

        }

    else

        {

        iCommands.Append( new( ELeave )TMCETestUIEngineCmdEnableVideoStream( 

            iEngine, *this ) );

        }	  

    iCommands.AppendL( new( ELeave )TMCETestUIEngineCmdRemoveStream( 

        iEngine, iVideoStream ) );

    return iCommands; 

    }

// -----------------------------------------------------------------------------

// CMCETestUIEngineVideoStream::Direction

// -----------------------------------------------------------------------------

//

EXPORT_C CMCETestUIEngineVideoStream::TVideoDirection 

    CMCETestUIEngineVideoStream::VideoDirection() const

    {

    return iVideoDirection;    

    }

// -----------------------------------------------------------------------------

// CMCETestUIEngineVideoStream::TextualDirection

// -----------------------------------------------------------------------------

//

EXPORT_C const TDesC16& 

    CMCETestUIEngineVideoStream::TextualVideoDirection() const

    {

    switch ( VideoDirection() )

        {

        case CMCETestUIEngineVideoStream::EUpLink :

            {

            return KStreamDirectionUpLink;

            break;

            }

        case CMCETestUIEngineVideoStream::EDownLink :

            {

            return KStreamDirectionDownLink;

            break;

            }           

        default:

            {

            break;

            }

        }

    return KStreamDirectionNotSpesified;

    }

// -----------------------------------------------------------------------------

// CMCETestUIEngineVideoStream::StreamState

// -----------------------------------------------------------------------------

//

EXPORT_C const TDesC16& CMCETestUIEngineVideoStream::StreamState() 

    {

    TInt state = iVideoStream.State();

	switch( state ) 

		{

		case CMceMediaStream::EUninitialized: 

		    return KStreamUninitialized; 

		    break;

		case CMceMediaStream::EInitialized: 

		    return KStreamInitialized; 

		    break;

		case CMceMediaStream::EBuffering: 

		    return KStreamBuffering; 

		    break;

		case CMceMediaStream::EIdle: 

		    return KStreamIdle; 

		    break;

		case CMceMediaStream::EStreaming: 

		    return KStreamStreaming; 

		    break;

		case CMceMediaStream::EDisabled: 

		    return KStreamDisabled; 

		    break;

		case CMceMediaStream::ENoResources: 

		    return KStreamNoResources; 

		    break;

		case CMceMediaStream::ETranscodingRequired: 

		    return KStreamTranscodingRequired; 

		    break;

		case CMceMediaStream::ETranscoding: 

		    return KStreamTranscoding; 

		    break;

		default: 

		    return KSessionStateUnknown; 

		    break;

		}    

    }

// -----------------------------------------------------------------------------

// CMCETestUIEngineVideoStream::State

// -----------------------------------------------------------------------------

//

EXPORT_C const TDesC16& CMCETestUIEngineVideoStream::State() const

    {

    if ( iVideoStream.IsEnabled() )

        {

        return KStreamStateEnabled;

        }

    return KStreamStateDisabled;

    }

// -----------------------------------------------------------------------------

// CMCETestUIEngineVideoStream::AudioStream

// -----------------------------------------------------------------------------

//

CMceVideoStream& CMCETestUIEngineVideoStream::VideoStream()

    {        

    return iVideoStream;

    }

// -----------------------------------------------------------------------------

// CMCETestUIEngineVideoStream::SolveDirection

// -----------------------------------------------------------------------------

//

CMCETestUIEngineVideoStream::TVideoDirection 

    CMCETestUIEngineVideoStream::SolveVideoDirection()

    {

    TBool isUpLink = EFalse;

    TBool isDownLink = EFalse;

    if ( iVideoStream.Source() )

        {

        if ( iVideoStream.Source()->Type() == KMceRTPSource )

            {

            isDownLink = ETrue;

            }

        }

    const RPointerArray<CMceMediaSink>& sinks = iVideoStream.Sinks();

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

        {

        if ( sinks[i]->Type() == KMceRTPSink )

            {

            isUpLink = ETrue;

            }

        }

    if ( isUpLink && isDownLink )

        {

        iVideoDirection = CMCETestUIEngineVideoStream::ENotSpesified;

        }

    else if ( isUpLink )

        {

        iVideoDirection = CMCETestUIEngineVideoStream::EUpLink;

        }

    else if ( isDownLink )

        {

        iVideoDirection = CMCETestUIEngineVideoStream::EDownLink;

        }  

    else

        {

        iVideoDirection = CMCETestUIEngineVideoStream::ENotSpesified;

        }

    return iVideoDirection; 

    }

// -----------------------------------------------------------------------------

// CMCETestUIEngineAudioStream::Sources

// -----------------------------------------------------------------------------

//

EXPORT_C const RPointerArray<CMCETestUIEngineVideoSource>& 

				CMCETestUIEngineVideoStream::SourcesL()

    {

	iSources.ResetAndDestroy();

	CMceMediaSource* source = iVideoStream.Source();

	CMCETestUIEngineVideoSource* engineSource = 

	    CMCETestUIEngineVideoSource::NewL(iEngine,*source);

	CleanupStack::PushL(engineSource);

	iSources.AppendL(engineSource);

	CleanupStack::Pop(engineSource);

	return iSources;

    }

// -----------------------------------------------------------------------------

// CMCETestUIEngineVideoStream::Sinks

// -----------------------------------------------------------------------------

//

EXPORT_C const RPointerArray<CMCETestUIEngineVideoSink>& 

    CMCETestUIEngineVideoStream::SinksL()

    {

    iSinks.ResetAndDestroy();

    const RPointerArray<CMceMediaSink>& sinks = iVideoStream.Sinks();

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

        {

        CMceMediaSink* sink = sinks[i];

        CMCETestUIEngineVideoSink* engineSink =

            CMCETestUIEngineVideoSink::NewL( iEngine, *sink);

        CleanupStack::PushL( engineSink );

        iSinks.AppendL( engineSink );

        CleanupStack::Pop( engineSink );                   

        }

	return iSinks;

    }

// -----------------------------------------------------------------------------

// CMCETestUIEngineVideoStream::Codecs

// -----------------------------------------------------------------------------

//

EXPORT_C  RPointerArray<CMCETestUIEngineVideoCodec>& 

    CMCETestUIEngineVideoStream::CodecsL()

    {

	iCodecs.ResetAndDestroy();

    const RPointerArray<CMceVideoCodec>& codecs = iVideoStream.Codecs();

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

        {

        CMceVideoCodec* codec = codecs[i];

        CMCETestUIEngineVideoCodec* engineCodec =

            CMCETestUIEngineVideoCodec::NewL( iEngine, *codec);

        CleanupStack::PushL( engineCodec );

        iCodecs.AppendL( engineCodec );

        CleanupStack::Pop( engineCodec );                   

        }

	return iCodecs;

    }

// -----------------------------------------------------------------------------

// CMCETestUIEngineVideoStream::CurrentCodecs

// -----------------------------------------------------------------------------

//

EXPORT_C RPointerArray<CMCETestUIEngineVideoCodec>& 

    CMCETestUIEngineVideoStream::CurrentCodecs()

    {

	return iCodecs;

    }