/*

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

#include "mceserial.h"

#include "mceevents.h"

#ifdef MCE_COMMON_SERVER_SIDE

#include <mmcccodecinformation.h>

#include "mcesrvstream.h"

#endif//MCE_COMMON_SERVER_SIDE

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

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

// CMceComCodec::CMceComCodec

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

//

CMceComCodec::CMceComCodec()

  : iID( TMceMediaId( (TUint32)&iID ) ),

    iPayloadType( 0 ),

    iIsEnabled( ETrue ),

    iBitrate( 0 ),

    iAllowedBitrates( 0 ),

    iCodecMode( 0 ),

    iFourCC( 0 ),

    iFrameSize( 0 ),

	iState( CMceCodec::EEnabled ),

	iPriority( 0 ),

	iPriorityPreference( 0 ),

    iKeepAliveTimer( 0 ),

    iKeepAlivePayloadType( 0 ),

    iIsNegotiated( ETrue ),

    iCodecSdpIndex( 0 ),

    iPreference( 0 )

        {

        }

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

// CMceComCodec::Id

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

//

TMceMediaId CMceComCodec::Id() const

    {

    return iID;

    }

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

// CMceComCodec::Stream

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

//

CMceComMediaStream* CMceComCodec::Stream() const

    {

    return iStream;

    }

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

// CMceComCodec::ConstructL

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

//

void CMceComCodec::ConstructL( CMceComCodec& aCodec )

    {

    iID = aCodec.iID;

    iSdpName = aCodec.iSdpName;

    iFmtpAttr = aCodec.iFmtpAttr ? aCodec.iFmtpAttr->AllocL() : NULL;

	iPayloadType = aCodec.iPayloadType;

	iFourCC = aCodec.iFourCC;

    iBitrate = aCodec.iBitrate;

	iAllowedBitrates = aCodec.iAllowedBitrates;

	iCodecMode = aCodec.iCodecMode;		

	iFrameSize = aCodec.iFrameSize;

	iState = aCodec.iState;

	iPriority = aCodec.iPriority;

	iPriorityPreference = aCodec.iPriorityPreference;

	iKeepAliveTimer = aCodec.iKeepAliveTimer;

	iKeepAlivePayloadType = aCodec.iKeepAlivePayloadType;

	if ( aCodec.iKeepAliveData )

	    {

	    SetKeepAliveDataL( *aCodec.iKeepAliveData );

	    }

    iIsNegotiated = aCodec.iIsNegotiated;

	iCodecSdpIndex = aCodec.iCodecSdpIndex;

    }

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

// CMceComCodec::SerializationId

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

//

TUint64 CMceComCodec::SerializationId() const

    {

    return iID.Uint64();

    }

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

// CMceComCodec::InternalizeFlatL

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

//

void CMceComCodec::InternalizeFlatL( RReadStream& aReadStream )

    {

    MceSerial::DecodeL( iSdpName, aReadStream );

    MceSerial::DecodeL( iID, aReadStream );

	iPayloadType = aReadStream.ReadUint8L();

	iFourCC = aReadStream.ReadUint32L();

	iFrameSize = aReadStream.ReadUint32L();

	iBitrate = aReadStream.ReadUint32L();

	iAllowedBitrates = aReadStream.ReadUint32L();

	iCodecMode = aReadStream.ReadUint32L();

	iState = aReadStream.ReadInt32L();

	iPriority = aReadStream.ReadInt32L();

	iPriorityPreference = aReadStream.ReadInt32L();

    iKeepAliveTimer = aReadStream.ReadUint32L();

    iKeepAlivePayloadType = aReadStream.ReadUint32L();

    MceSerial::DecodeL( iKeepAliveData, aReadStream );

    }

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

// CMceComCodec::ExternalizeFlatL

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

//

void CMceComCodec::ExternalizeFlatL( RWriteStream& aWriteStream )

    {

    MceSerial::EncodeL( iSdpName, aWriteStream );

    MceSerial::EncodeL( iID, aWriteStream );

    aWriteStream.WriteUint8L( iPayloadType );

    aWriteStream.WriteUint32L( iFourCC );

    aWriteStream.WriteUint32L( iFrameSize );

    aWriteStream.WriteUint32L( iBitrate );

    aWriteStream.WriteUint32L( iAllowedBitrates );

    aWriteStream.WriteUint32L( iCodecMode );

    aWriteStream.WriteInt32L( iState );

    aWriteStream.WriteInt32L( iPriority );

    aWriteStream.WriteInt32L( iPriorityPreference );

    aWriteStream.WriteInt32L( iKeepAliveTimer );

    aWriteStream.WriteInt32L( iKeepAlivePayloadType );

    MceSerial::EncodeL( iKeepAliveData, aWriteStream );

    }

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

// CMceComCodec::InternalizeL

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

//

void CMceComCodec::InternalizeL( MMceComSerializationContext& aSerCtx )

    {

    InternalizeFlatL( aSerCtx.ReadStream() );

    }

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

// CMceComCodec::ExternalizeL

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

//

void CMceComCodec::ExternalizeL( MMceComSerializationContext& aSerCtx )

    {

    ExternalizeFlatL( aSerCtx.WriteStream() );

    }

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

// CMceComCodec::UpdateL

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

//

void CMceComCodec::UpdateL( CMceComCodec& aUpdate )

    {

    iSdpName = aUpdate.iSdpName;

    iID = aUpdate.iID;

    iPayloadType = aUpdate.iPayloadType;

    iFourCC = aUpdate.iFourCC;

    iBitrate = aUpdate.iBitrate;

    iAllowedBitrates = aUpdate.iAllowedBitrates;

    iCodecMode = aUpdate.iCodecMode;

	iState = aUpdate.iState;

	iPriority = aUpdate.iPriority;

	iPriorityPreference = aUpdate.iPriorityPreference;

    iKeepAliveTimer = aUpdate.iKeepAliveTimer;

    iKeepAlivePayloadType = aUpdate.iKeepAlivePayloadType;

    if ( aUpdate.iKeepAliveData )

        {

        delete iKeepAliveData;

        iKeepAliveData = aUpdate.iKeepAliveData;

        aUpdate.iKeepAliveData = NULL;

        }

    else

        {

        SetKeepAliveDataL( KNullDesC8 );

        }

    }

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

// CMceComCodec::ConstructL

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

//

void CMceComCodec::ConstructL( TMceComCodecName aSdpName )

    {

    iSdpName = aSdpName;

    SetKeepAliveDataL( KNullDesC8 );

    SetFmtpAttributeL( KNullDesC8 );

    }

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

// CMceComCodec::Decodes

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

//

TBool CMceComCodec::Decodes( 

    const TDesC8& aRtpmapValue, 

    const TDesC8& /*aFmtpValue*/,

    TBool /*aIsStrictMatch*/ )

    {

    }

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

// CMceComCodec::BaseFactory

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

//

TMceComFactory CMceComCodec::BaseFactory()

    {

    return TMceComFactory();

    }

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

// CMceComCodec::FmtpAttr

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

//

TPtrC8 CMceComCodec::FmtpAttr() const

    {

    TPtrC8 existingFmtpVal( KNullDesC8() );

    if ( iFmtpAttr && iFmtpAttr->Length() > 0 )

        {

        existingFmtpVal.Set( *iFmtpAttr );

        }

    else if ( iFmtpProposal )

        {

        existingFmtpVal.Set( *iFmtpProposal );

        }

    else

        {

        // NOP

        }

    return existingFmtpVal;

    }

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

// CMceComCodec::SetFmtpAttributeL

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

//

void CMceComCodec::SetFmtpAttributeL( const TDesC8& aFmtpAttribute, TBool aReset )

    {

    if ( aReset || !iFmtpAttr )

        {

        HBufC8* fmtpAttr = aFmtpAttribute.AllocL();

        delete iFmtpAttr;

        iFmtpAttr = fmtpAttr;

        }

    else

        {

        iFmtpAttr = iFmtpAttr->ReAllocL( iFmtpAttr->Length() + 

                                         KMceFmtpSeparator().Length() +

                                         aFmtpAttribute.Length() );

        iFmtpAttr->Des().Append( KMceFmtpSeparator );

        iFmtpAttr->Des().Append( aFmtpAttribute );

        }

    }

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

// CMceComCodec::~CMceComCodec

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

//

CMceComCodec::~CMceComCodec()

    {

    delete iFmtpAttr;

    iFmtpAttr = NULL;

    delete iKeepAliveData;

    iKeepAliveData = NULL;

    delete iFmtpProposal;

    iFmtpProposal = NULL;

    }

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

// CMceComCodec::EventReceivedL

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

//

TInt CMceComCodec::EventReceivedL( TMceEvent& aEvent )

    {

    TInt status = KMceEventNotOwner;

    TBool idMatch = aEvent.Id().iCodecID == iID;

    if ( !idMatch )

        {

        return KMceEventNotOwner;

        }

    if ( aEvent.Id().IsCodecId() )

        {

        status = KMceEventUpdate;

        }

    else

        {

        status = KMceEventNotConsumed;

        }

    return status;

    }

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

// CMceComCodec::ResolveAllowedBitrates

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

//

TInt CMceComCodec::ResolveAllowedBitrates( 

    TUint /*aBitrate*/, TUint& /*aAllowedBitrates*/ )

    {

    return KErrNotSupported;

    }

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

// CMceComCodec::SetEnabled

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

//

void CMceComCodec::SetEnabled( TBool aIsEnabled )

    {

    iIsEnabled = aIsEnabled;

    }

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

// CMceComCodec::SendSupported

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

//

TBool CMceComCodec::SendSupported()

    {

    return ETrue;

    }

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

// CMceComCodec::IsEnabled

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

//

TBool CMceComCodec::IsEnabled() const

    {

    return iIsEnabled;

    }

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

// CMceComCodec::InitializeL

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

//

void CMceComCodec::InitializeL( CMceComMediaStream& aParent )

    {

    iStream = &aParent;

    }

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

// CMceComCodec::SetKeepAliveDataL

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

//

void CMceComCodec::SetKeepAliveDataL( const TDesC8& aKeepAliveData )

    { 

    HBufC8* keepaliveData = aKeepAliveData.AllocL();

    delete iKeepAliveData;

    iKeepAliveData = keepaliveData;

    }

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

// CMceComCodec::SetBitrate

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

//

TInt CMceComCodec::SetBitrate( TUint aBitrate )

    {

    if ( aBitrate )

        {

        iBitrate = aBitrate;

        return KErrNone;

        }

    else

        {

        return KErrArgument;

        }

    }

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

// CMceComCodec::SetAllowedBitrates

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

//

TInt CMceComCodec::SetAllowedBitrates( TUint aBitrates )

    {

    iAllowedBitrates = aBitrates;

    return KErrNone;

    }

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

// CMceComCodec::SetCodecMode

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

//

TInt CMceComCodec::SetCodecMode( TUint /*aCodecMode*/ )

    {

    return KErrNotSupported;

    }

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

// CMceComCodec::SetPayloadType

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

//

TInt CMceComCodec::SetPayloadType( TUint8 aPayloadType )

    {

    if ( aPayloadType <= KMaxDynPayloadType )

        {

        iPayloadType = aPayloadType;

        return KErrNone;

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMceComCodec::GetMaxBitRate

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

//

TUint CMceComCodec::GetMaxBitRate()

    {

    return iBitrate;

    }

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

// CMceComCodec::TIterator::TIterator

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

//

CMceComCodec::TIterator::TIterator( const RPointerArray<CMceComCodec>& aCodecs, 

                                    CMceComCodec::TIterator::TFilter aFilter,

                                    CMceComCodec* aCodec )

    : iFilter( aFilter ),

      iCodecs( aCodecs ),

      iCurrentIndex( 0 ),

      iCodec( aCodec )

    {

    }

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

// CMceComCodec::TIterator::IsEof

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

//

TBool CMceComCodec::TIterator::IsEof()

    {

    return iCodecs.Count() == 0 || iCurrentIndex >= iCodecs.Count();

    }

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

// CMceComCodec::TIterator::Next

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

//

TBool CMceComCodec::TIterator::Next( 

    CMceComCodec*& aCandidate,  

    TIterator::TStreamStateMatchType aMatchType )

    {

    CMceComCodec* next = NULL;

    while( !next && !IsEof() )

        {

        CMceComCodec* codec = iCodecs[ iCurrentIndex ];

        TBool condition = EFalse;

        switch( iFilter )

            {

            case EFilterIsNegotiated:

                {

                condition = codec->iIsNegotiated;

                break;

                }

            case EFilterAssociatedLocal:

                {

                if ( iCodec && 

                     iCodec->Stream() &&

                     codec->Stream() &&

                     codec->Stream()->iStreamType == CMceComMediaStream::ELocalStream &&

                     ( ( aMatchType == EOtherSdpName && 

                         !codec->Decodes( iCodec->iSdpName, iCodec->FmtpAttr() ) ) || 

                       ( aMatchType == EExactMatch && 

                         codec->Decodes( iCodec->iSdpName, iCodec->FmtpAttr() ) ) ) )

                    {

                    CMceComMediaSource* source1 = iCodec->Stream()->Source();

                    CMceComMediaSource* source2 = codec->Stream()->Source();

                    condition = ( source1 != NULL && source1 == source2 );

                    }

                break;

                }

            default:

                {

                condition = ETrue;

                break;

                }