/*

* Copyright (c) 2008 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 <s32buf.h>

#include "mceinsession.h"

#include "mceoutsession.h"

#include "mceaudiostream.h"

#include "mcevideostream.h"

#include "mcertpsource.h"

#include "mcemicsource.h"

#include "mcecamerasource.h"

#include "mcefilesource.h"

#include "mcefilesink.h"

#include "mcertpsink.h"

#include "mcespeakersink.h"

#include "mcedisplaysink.h"

#include "mceamrcodec.h"

#include "mceamrwbcodec.h"

#include "mceg711codec.h"

#include "mceg729codec.h"

#include "mceilbccodec.h"

#include "mcedtmfcodec.h"

#include "mcecncodec.h"

#include "mceredcodec.h"

#include "mceh263codec.h"

#include "mcefactory.h"

#include "mceserial.h"

#include "mcedefs.h"

#include "mcevideocodec.h"

#include "mcestreambundle.h"

#include "mceavsink.h"

#include "mceavccodec.h"

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

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

// TMceFactory::CreateLC

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

//

CMceSession* TMceFactory::CreateLC( CMceComSession::TType aType )

	{

    CMceSession* session = NULL;

    switch ( aType )

        {

        case CMceComSession::EInSession:

            {

            session = CMceInSession::NewL();

            CleanupStack::PushL( session );

            break;

            }

        case CMceComSession::EOutSession:

            {

            session = CMceOutSession::NewL();

            CleanupStack::PushL( session );

            break;

            }

        default:

            {

            break;

            }

        }

    if ( !session )

        {

        User::Leave( KErrNotSupported );

        }

    return session;    

	}

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

// TMceFactory::CreateLC

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

//

CMceSession* TMceFactory::CreateLC( MMceComSerializationContext& aSerCtx )

    {

    RReadStream& readStream = aSerCtx.ReadStream();

    MStreamBuf* streamBuf = readStream.Source();

    TStreamPos pos = streamBuf->TellL( MStreamBuf::ERead );

    CMceComSession::TType type =

    	static_cast<CMceComSession::TType>( readStream.ReadUint8L() );

    streamBuf->SeekL( MStreamBuf::ERead, pos );

    CMceSession* session = CreateLC( type );

    session->InternalizeL( aSerCtx );

    return session;    

    }

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

// TMceFactory::CreateL

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

//

CMceMsgBase* TMceFactory::CreateL( TMceItcDataType aType,

                                   RReadStream& aReadStream )

    {

    MMceComSerializationContext serCtx( aReadStream );

    CleanupClosePushL( serCtx );

    CMceMsgBase* object = CreateL( aType, serCtx );

    CleanupStack::PopAndDestroy();//serCtx

    return object;

    }

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

// TMceFactory::CreateL

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

//

CMceMsgBase* TMceFactory::CreateL( TMceItcDataType aType,

                                   MMceComSerializationContext& aSerCtx )

    {

    CMceMsgBase* message = NULL;

    switch ( aType )

        {

        case EMceItcMsgTypeSession:

            {

            message = new (ELeave) CMceMsgObject<CMceSession>();

        	break;

            }

        case EMceItcMsgTypeStream:

            {

            message = new (ELeave) CMceMsgObject<CMceMediaStream>();

        	break;

            }

        case EMceItcMsgTypeCodec:

            {

            message = new (ELeave) CMceMsgObject<CMceAudioCodec>();

        	break;

            }

        case EMceItcMsgTypeSink:

            {

            message = new (ELeave) CMceMsgObject<CMceMediaSink>();

        	break;

            }

        case EMceItcMsgTypeSource:

            {

            message = new (ELeave) CMceMsgObject<CMceMediaSource>();

        	break;

            }

        case EMceItcMsgTypeSIPData:

            {

            message = new (ELeave) CMceMsgSIPData();

        	break;

            }

        case EMceItcMsgTypeSIPReply:

            {

            message = new (ELeave) CMceMsgSIPReply();

        	break;

            }

        case EMceItcMsgTypeSIPRequest:

            {

            message = new (ELeave) CMceMsgSIPRequest();

        	break;

            }    

        case EMceItcMsgTypeEvent:

            {

            message = new (ELeave) CMceMsgSIPEvent();

        	break;

            }

        case EMceItcMsgTypeTextArray:

            {

            message = new (ELeave) CMceMsgTextArray();

        	break;

            }

        case EMceItcMsgTypeMessageArray:

            {

            message = new (ELeave) CMceMsgArray<TMceFactory>( *this );

        	break;

            }

	    default:

	        {

	        }

        }

    if ( message )

        {

    	CleanupStack::PushL( message );

    	message->PushL();

        message->DoDecodeL( aSerCtx );

        message->Pop();

        CleanupStack::Pop( message );

        }

    return message;

    }

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

// TMceFactory::CreateL

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

//

CMceStreamBundle* TMceFactory::CreateBundleLC( CMceSession& aSession, 

                                               MMceComSerializationContext& aSerCtx )

    {

    RReadStream& readStream = aSerCtx.ReadStream();

    MStreamBuf* streamBuf = readStream.Source();

    TStreamPos pos = streamBuf->TellL( MStreamBuf::ERead );

    CMceStreamBundle::TMceStreamBundleType type =

    	static_cast<CMceStreamBundle::TMceStreamBundleType>( readStream.ReadUint8L() );

    streamBuf->SeekL( MStreamBuf::ERead, pos );

    CMceStreamBundle* bundle = CMceStreamBundle::NewLC( type );

    bundle->InitializeL( aSession );

    bundle->InternalizeL( aSerCtx );

    return bundle;

    }

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

// TMceMediaStreamFactory::CreateLC

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

//

CMceMediaStream* TMceMediaStreamFactory::CreateLC( TMceMediaType aType )

	{

    CMceMediaStream* stream = NULL;

    switch ( aType )

        {

        case KMceAudio:

            {

            stream = CMceAudioStream::NewLC();

            break;

            }

        case KMceVideo:

            {

            stream = CMceVideoStream::NewLC();

            break;

            }            

        default:

            {

            break;

            }

        }

    if ( !stream )

        {

        User::Leave( KErrNotSupported );

        }

    return stream;

	}

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

// TMceMediaStreamFactory::CreateLC

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

//

CMceMediaStream* TMceMediaStreamFactory::CreateLC(

                                        MMceComSerializationContext& aSerCtx )

    {

    RReadStream& readStream = aSerCtx.ReadStream();

    MStreamBuf* streamBuf = readStream.Source();

    TStreamPos pos = streamBuf->TellL( MStreamBuf::ERead );

    TMceMediaType type = static_cast<TMceMediaType>( readStream.ReadUint8L() );

    streamBuf->SeekL( MStreamBuf::ERead, pos );

    CMceMediaStream* stream = CreateLC( type );

    stream->InternalizeL( aSerCtx );

    return stream;

    }

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

// TMceSourceFactory::CreateLC

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

//

CMceMediaSource* TMceSourceFactory::CreateLC( TMceSourceType aType )

    {

    CMceMediaSource* source = NULL;

    switch ( aType )

        {

        case KMceRTPSource:

            {

            source = CMceRtpSource::NewLC();

            break;

            }

        case KMceMicSource:

            {

            source = CMceMicSource::NewLC();

            break;

            }

        case KMceCameraSource:

            {

            source = CMceCameraSource::NewLC();

            break;

            }

        case KMceFileSource:

            {

            source = CMceFileSource::NewLC();

            break;

            }

        default:

            {

            break;

            }

        }

    if ( !source )

        {

        User::Leave( KErrNotSupported );

        }

    return source;

    }

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

// TMceSourceFactory::CreateLC

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

//

CMceMediaSource* TMceSourceFactory::CreateLC( MMceComSerializationContext& aSerCtx )

    {

    RReadStream& readStream = aSerCtx.ReadStream();

    MStreamBuf* streamBuf = readStream.Source();

    TStreamPos pos = streamBuf->TellL( MStreamBuf::ERead );

    TMceSourceType type = static_cast<TMceSourceType>( readStream.ReadUint8L() );

    streamBuf->SeekL( MStreamBuf::ERead, pos );

    CMceMediaSource* source = CreateLC( type );

    source->InternalizeL( aSerCtx );

    return source;

    }

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

// TMceSinkFactory::CreateLC

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

//

CMceMediaSink* TMceSinkFactory::CreateLC( TMceSinkType aType )

    {

    CMceMediaSink* sink = NULL;

    switch ( aType )

        {

        case KMceRTPSink:

            {

            sink = CMceRtpSink::NewLC();

            break;

            }

        case KMceSpeakerSink:

            {

            sink = CMceSpeakerSink::NewLC();

            break;

            }

        case KMceDisplaySink:

            {

            sink = CMceDisplaySink::NewLC();

            break;

            }

        case KMceFileSink:

            {

            sink = CMceFileSink::NewLC();

            break;

            }

        default:

            {

            break;

            }

        }

    if ( !sink )

        {

        User::Leave( KErrNotSupported );

        }

    return sink;

    }

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

// TMceSinkFactory::CreateLC

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

//

CMceMediaSink* TMceSinkFactory::CreateLC( MMceComSerializationContext& aSerCtx )

    {

    RReadStream& readStream = aSerCtx.ReadStream();

    MStreamBuf* streamBuf = readStream.Source();

    TStreamPos pos = streamBuf->TellL( MStreamBuf::ERead );

    TMceSinkType type = static_cast<TMceSinkType>( readStream.ReadUint8L() );

    streamBuf->SeekL( MStreamBuf::ERead, pos );

    CMceMediaSink* sink = CreateLC( type );

    sink->InternalizeL( aSerCtx );

    return sink;

    }

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

// TMceSinkFactory::CreateLC

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

//

void TMceSinkFactory::CreateLC( MMceComSerializable*& aSink, MMceComSerializationContext& aSerCtx )

    {

    RReadStream& readStream = aSerCtx.ReadStream();

    MStreamBuf* streamBuf = readStream.Source();

    TStreamPos pos = streamBuf->TellL( MStreamBuf::ERead );

    TMceSinkType type = static_cast<TMceSinkType>( readStream.ReadUint8L() );

    streamBuf->SeekL( MStreamBuf::ERead, pos );

    switch ( type )

        {

        case KMceAvSink:

            {

            aSink = CMceAvSink::NewLC();

            break;

            }

        default:

            {

            break;

            }

        }

    if ( !aSink )

        {

        User::Leave( KErrNotSupported );

        }

    aSink->InternalizeL( aSerCtx );

    }

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

// TMceAudioCodecFactory::CreateLC

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

//

CMceAudioCodec* TMceAudioCodecFactory::CreateLC( TBuf8<KMceMaxSdpNameLength> aSdpName )

    {

    CMceAudioCodec* codec = CreateL( aSdpName );

    CleanupStack::PushL( codec );

	return codec;     

    }

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

// TMceAudioCodecFactory::CreateL

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

//

CMceAudioCodec* TMceAudioCodecFactory::CreateL( TBuf8<KMceMaxSdpNameLength> aSdpName )

    {

    CMceAudioCodec* codec = NULL;

    if( !aSdpName.CompareF( KMceSDPNameAMR ) )

        {

        codec = CMceAmrCodec::NewL( aSdpName );

        }

    else if ( !aSdpName.CompareF( KMceSDPNameAMRWB ) )

    	{

		codec = CMceAmrWbCodec::NewL( aSdpName );

    	}

    else if ( !aSdpName.CompareF( KMceSDPNamePCMU ) ||

              !aSdpName.CompareF( KMceSDPNamePCMA ) )

        {

        codec = CMceG711Codec::NewL( aSdpName );

        }

    else if ( !aSdpName.CompareF( KMceSDPNameG729 ) )        

        {

        codec = CMceG729Codec::NewL( aSdpName );   

        }     

    else if ( !aSdpName.CompareF( KMceSDPNameiLBC ) )        

        {

        codec = CMceiLBCCodec::NewL( aSdpName );

        }

    else if ( !aSdpName.CompareF( KMceSDPNameDtmf ) )

        {

        codec = CMceDtmfCodec::NewL( aSdpName );

        }

    else if ( !aSdpName.CompareF( KMceSDPNameCn ) )

        {

        codec = CMceCnCodec::NewL( aSdpName );

        }

    else if ( !aSdpName.CompareF( KMceSDPNameRed ) )

        {

        codec = CMceRedCodec::NewL( aSdpName );

        }

    else

        {

        User::Leave( KErrNotSupported );

        }

	return codec;

    }

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

// TMceAudioCodecFactory::CreateLC

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

//

CMceAudioCodec* TMceAudioCodecFactory::CreateLC( MMceComSerializationContext& aSerCtx )

    {

    RReadStream& readStream = aSerCtx.ReadStream();