/*

* Copyright (c) 2006 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 FILES

#include "mcemediadefs.h"

#include "mcemediasdpcodec.h"

#include "mcecomcodec.h"

#include "mcemmlogs.h"

#include "mcepreconditions.h"

#include "mcesdpsession.h"

#include "mcesip.h"

#include "mcemediamanager.h"

#include "mcenatpluginmanager.h"

#include <sdpconnectionfield.h>

#include <sdpdocument.h>

#include <sdpcodecstringconstants.h>

#include <sdpcodecstringpool.h>

#include <sdpmediafield.h>

#include <sdpattributefield.h>

#include <sdprtpmapvalue.h>

#include <sdpfmtattributefield.h>

#include <sdporiginfield.h>

#include <sdpbandwidthfield.h>

#include <mmcccodecinformation.h>

#include <sdpcodecstringpool.h>

#include <delimitedpathsegment8.h>

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

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

// CMceMediaSdpCodec::CMceMediaSdpCodec

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

CMceMediaSdpCodec::CMceMediaSdpCodec( RStringF aMedia )

    : CMceSdpCodec( aMedia )

    {

    }

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

// CMceMediaSdpCodec::~CMceMediaSdpCodec

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

CMceMediaSdpCodec::~CMceMediaSdpCodec()

    {

    }

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

// CMceMediaSdpCodec::EncodeMediaOfferL

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

//

void CMceMediaSdpCodec::EncodeMediaOfferL( 

    CMceComMediaStream& aStream, 

    CSdpMediaField& aMediaLine, 

    CSdpDocument& aSdpDocument )

    { 

    MCEMM_DEBUG("CMceMediaSdpCodec::EncodeMediaOfferL(), Entry ")

    // get all the codecs to be offered for this media stream.

    const RPointerArray<CMceComCodec>& allCodecs = CodecsL( aStream );

    CMceComCodec* codec = NULL;

    CMceComCodec::TIterator codecs( allCodecs, CMceComCodec::TIterator::EFilterIsNegotiated );

    // Set the fmt list containing all supported payload 

    // types supported by this media

    // i.e. all the rtpmap fields in the pointer array

    HBufC8* fmtlist = CreateFormatListL( codecs );

    CleanupStack::PushL( fmtlist ); 

    codecs.Reset();

    aMediaLine.SetFormatListL( *fmtlist );

    CleanupStack::PopAndDestroy( fmtlist ); 

    MCEMM_DEBUG_SVALUE("encoded formatlist", aMediaLine.FormatList() )

    // For each codec supported by this stream create a rtpmap field

    // e.g. a=rtpmap: 97 AMR/8000

    // and ptime and maxptime

    // e.g. a=ptime:20 a=maxptime:40

    while( codecs.Next( codec ) )

        {

        CSdpFmtAttributeField* rtpmap = EncodeRtpmapAttributeLC( *codec );

        EncodeMediaAttributesL( *codec, aMediaLine, *rtpmap );

        aMediaLine.FormatAttributeFields().AppendL( rtpmap );

        CleanupStack::Pop( rtpmap );

        EncodeFmtpAttributeL( *codec, aMediaLine );

        }  

    //encode direction

    EncodeDirectionL( aStream, aMediaLine, aSdpDocument, EMceRoleOfferer );

    //encode client attributes if any

    EncodeClientAttributesL( aStream, aMediaLine );

    //encode secure session if any

    EncodeSecureSessionL( aStream, aMediaLine, EMceRoleOfferer );

    //encode preconditions if any

    EncodePreconditionsL( aStream, aMediaLine, EMceRoleOfferer );

    //encode rtcp port 

    EncodelocalRtcpAttrL( aMediaLine, aStream );

    MCEMM_DEBUG("CMceMediaSdpCodec::EncodeMediaOfferL(), Exit ")

    }

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

// CMceMediaSdpCodec::DecodeMediaAnswerL

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

//

TMceSipWarningCode CMceMediaSdpCodec::DecodeMediaAnswerL( 

    CSdpMediaField& aMediaLine, 

    CMceComMediaStream& aStream,

    CSdpDocument& aSdpDocument )

    {

    MCEMM_DEBUG("CMceMediaSdpCodec::DecodeMediaAnswerL(), Entry ")

    //should have secure session created

    const RPointerArray<CMceComCodec>& allCodecs = CodecsL( aStream );

    CMceComCodec::TIterator codecs( allCodecs );

    //decode direction or old school hold if necessary                                            

    DecodeDirectionL( aMediaLine, aStream, aSdpDocument, EMceRoleOfferer );

    __ASSERT_ALWAYS( codecs.Count() > 0, User::Leave( KErrNotReady ) );

    __ASSERT_ALWAYS( aMediaLine.Port() != 0 , User::Leave( KErrNotReady ) );

    //decode based on rtpmaps + their media attributes

    TInt decoded = DecodePayloadsL( aMediaLine, aStream, EMceRoleOfferer );

    if ( !decoded )

        {

        MCEMM_DEBUG("ERROR: No codecs decoded")

        User::Leave( KErrNotReady );

        }

	 // check if remote RTCP port is set according to RFC 3605

    DecodeRemoteRtcpFieldL( aMediaLine, aStream );

    aStream.SetRemoteMediaPort( aMediaLine.Port() );

    MCEMM_DEBUG_DVALUE("decoded remote port", aStream.RemoteMediaPort() )

    //decode based on fmtps

    DecodeFmtpLinesL( aMediaLine, codecs, EMceRoleOfferer );

	 //decode secure session if any

    DecodeSecureSessionL( aMediaLine, aStream, EMceRoleOfferer );

    //decode preconditions if any

    TMceSipWarningCode warnings = 

        DecodePreconditionsL( aMediaLine, aStream, EMceRoleOfferer );

    //decode client attributes if any

    DecodeClientAttributesL( aMediaLine, aStream );

    MCEMM_DEBUG("CMceMediaSdpCodec::DecodeMediaAnswerL(), Exit ")

    return warnings;

    }    

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

// CMceMediaSdpCodec::DecodeMediaOfferL

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

//

TMceSipWarningCode CMceMediaSdpCodec::DecodeMediaOfferL( 

    CSdpMediaField& aMediaLine,

    CMceComMediaStream*& aStream,

    CMceComSession& aSession,

    CSdpDocument& aSdpDocument )

    {

    MCEMM_DEBUG("CMceMediaSdpCodec::DecodeMediaOfferL(), Entry ")

    TMceSipWarningCode warning = ValidateSdpL( aMediaLine, aSdpDocument );

    if ( warning != KErrNone )

        {

        return warning;

        }

    TInt type = Type( aMediaLine, aSdpDocument.AttributeFields() );

    // create server stream based on the media direction 

    // attribute (sendonly, sendrcv, rcvonly)

    aStream = CreateStreamLC( type );

    aStream->InitializeL( aSession );

    //decode direction or old school hold if necessary                                            

    DecodeDirectionL( aMediaLine, *aStream, aSdpDocument, EMceRoleAnswerer );

    const RPointerArray<CMceComCodec>& allCodecs = CodecsL( *aStream );

    CMceComCodec::TIterator codecs( allCodecs );

    //decode based on rtpmaps + their media attributes

    TInt decoded = DecodePayloadsL( aMediaLine, *aStream, EMceRoleAnswerer );

    if ( decoded )

        {

        // check if remote RTCP port is set according to RFC 3605

        DecodeRemoteRtcpFieldL( aMediaLine, *aStream );

        aStream->SetRemoteMediaPort( aMediaLine.Port() );

        MCEMM_DEBUG_DVALUE("decoded remote port", aStream->RemoteMediaPort() )

        //decode based on fmtps

        DecodeFmtpLinesL( aMediaLine, codecs, EMceRoleAnswerer );

        //decode session level media attributes        

        DecodeSessionMediaAttributesL( *aStream, aSdpDocument );

        //decode secure session if any

       	DecodeSecureSessionL( aMediaLine, *aStream, EMceRoleAnswerer );

       	//decode preconditions if any

        warning = DecodePreconditionsL( aMediaLine, *aStream, EMceRoleAnswerer );

        //Decode client attributes if any

        DecodeClientAttributesL( aMediaLine, *aStream );

        aSession.Streams().AppendL( aStream );

        CleanupStack::Pop( aStream );

        }

    else

        {

        MCEMM_DEBUG("No acceptable codecs found for current media line ")

        // we did not find any acceptable codecs for this stream, return warning

        CleanupStack::PopAndDestroy( aStream );

        aStream = NULL;

        warning = KMceSipWarnIncompatibleMediaFormat;

        }

    MCEMM_DEBUG("CMceMediaSdpCodec::DecodeMediaOfferL(), Exit ")

    return warning;

    }

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

// CMceMediaSdpCodec::DecodeMediaUpdateL

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

//

TMceSipWarningCode CMceMediaSdpCodec::DecodeMediaUpdateL( 

    CSdpMediaField& aMediaLine, 

    CMceComMediaStream& aStream,

    CSdpDocument& aSdpDocument )

    {

    MCEMM_DEBUG("CMceMediaSdpCodec::DecodeMediaUpdateL(), Entry ")

    TMceSipWarningCode warning = ValidateSdpL( aMediaLine, aSdpDocument );

    if ( warning != KErrNone )

        {

        return warning;

        }

    const RPointerArray<CMceComCodec>& allCodecs = CodecsL( aStream );

    CMceComCodec::TIterator codecs( allCodecs );

    aStream.SetRemoteMediaPort( aMediaLine.Port() );

    MCEMM_DEBUG_DVALUE("decoded remote port", aStream.RemoteMediaPort() )

    //should have secure media session existed

    //decode based on rtpmaps + their media attributes

    TInt decoded = DecodePayloadsL( aMediaLine, aStream, EMceRoleAnswerer );

    if ( decoded )

        {

        // check if remote RTCP port is set according to RFC 3605

        DecodeRemoteRtcpFieldL( aMediaLine, aStream );

        //decode based on fmtps

        DecodeFmtpLinesL( aMediaLine, codecs, EMceRoleAnswerer );

        //decode direction or old school hold if necessary                                            

        UpdateDirectionL( aMediaLine, aStream, aSdpDocument );

        //decode secure session if any

       	DecodeSecureSessionL( aMediaLine, aStream, EMceRoleAnswerer, KMceMediaCodecUpdate );

		//decode preconditions if any

        warning = DecodePreconditionsL( aMediaLine, aStream, EMceRoleAnswerer );

        //decode client attributes if any

        DecodeClientAttributesL( aMediaLine, aStream );

	    }

    else

        {

        MCEMM_DEBUG("ERROR: No codecs decoded")

        warning = KMceSipWarnIncompatibleMediaFormat;

        }

    MCEMM_DEBUG("CMceMediaSdpCodec::DecodeMediaUpdateL(), Exit ")

    return warning;

    }

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

// CMceAudioSdpCodec::EncodeMediaAnswerL

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

//

void CMceMediaSdpCodec::EncodeMediaAnswerL( 

    CMceComMediaStream& aStream,

    CSdpMediaField& aMediaLine,

    CSdpDocument& aSdpDocument )

    {

    MCEMM_DEBUG("CMceMediaSdpCodec::EncodeMediaAnswerL(), Entry ")

    const RPointerArray<CMceComCodec>& allCodecs = CodecsL( aStream );  

    CMceComCodec* codec = NULL;

    CMceComCodec::TIterator codecs( allCodecs, CMceComCodec::TIterator::EFilterIsNegotiated );

    if ( codecs.Count() > 0 ) 

        {

        // Set the fmt list containing all supported payload 

        // types supported by this media

        // i.e. all the rtpmap fields in the pointer array

        HBufC8* fmtlist = CreateFormatListL( codecs );

        CleanupStack::PushL( fmtlist ); 

        codecs.Reset();

        aMediaLine.SetFormatListL( *fmtlist );

        CleanupStack::PopAndDestroy( fmtlist ); 

        MCEMM_DEBUG_SVALUE("encoded formatlist", aMediaLine.FormatList() )

        aMediaLine.SetPortL( aStream.iLocalMediaPort );

        MCEMM_DEBUG_DVALUE("encoded local port", aMediaLine.Port() )

        // add the direction attribute

        EncodeDirectionL( aStream, aMediaLine, aSdpDocument, EMceRoleAnswerer );

        while( codecs.Next( codec ) )

            {

            CSdpFmtAttributeField* rtpmap = EncodeRtpmapAttributeLC( *codec );

            EncodeMediaAttributesL( *codec, aMediaLine, *rtpmap );

            aMediaLine.FormatAttributeFields().AppendL( rtpmap );

            CleanupStack::Pop( rtpmap );

            EncodeFmtpAttributeL( *codec, aMediaLine );

            }

        //encode secure session if any

        EncodeSecureSessionL( aStream, aMediaLine, EMceRoleAnswerer );

        //encode preconditions if any

        EncodePreconditionsL( aStream, aMediaLine, EMceRoleAnswerer );

        }

    else

        { // there was no selected codec for this stream

        MCEMM_DEBUG("ERROR: No selected codec found! Reject ")

        aMediaLine.RejectMedia();

        }

    // encode client attributes

    EncodeClientAttributesL( aStream, aMediaLine );

	// encode rtcp attributes

	EncodelocalRtcpAttrL( aMediaLine, aStream );

    MCEMM_DEBUG("CMceMediaSdpCodec::EncodeMediaAnswerL(), Exit ")

    }

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

// CMceMediaSdpCodec::TypeL

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

//

TInt CMceMediaSdpCodec::Type( 

    CSdpMediaField& aMedia, 

    RPointerArray<CSdpAttributeField>& aSessionAttributes ) const

    {

    TInt type = Direction( aMedia, aSessionAttributes );

    type = type == KErrNotFound ? SdpCodecStringConstants::EAttributeSendrecv : type; 

    return type;

    }

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

// CMceMediaSdpCodec::PrepareForDecodeL

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

//

void CMceMediaSdpCodec::PrepareForDecodeL( 

    CSdpMediaField& /*aMediaLine*/,

    CMceComMediaStream* aStream )

    {

    MCEMM_DEBUG("CMceMediaSdpCodec::PrepareForDecodeL(), Entry ")

    if ( aStream )

        {

        const RPointerArray<CMceComCodec>& allCodecs = CodecsL( *aStream );

        CMceComCodec* codec = NULL;

        CMceComCodec::TIterator codecs( allCodecs );

        while( codecs.Next( codec ) )

            {

            codec->iIsNegotiated = EFalse;

            }

        }

    MCEMM_DEBUG("CMceMediaSdpCodec::PrepareForDecodeL(), Exit ")

    }

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

// CMceMediaSdpCodec::DecodeRtpmapLinesL

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

//

TInt CMceMediaSdpCodec::DecodeRtpmapLinesL( 

    CSdpMediaField& aMediaLine,

    CMceComMediaStream& aStream,

    TMceNegotiationRole aRole ) const

    {

    MCEMM_DEBUG("CMceMediaSdpCodec::DecodeRtpmapLinesL(), Entry ")

    TInt decoded = 0;

    const RPointerArray<CMceComCodec>& allCodecs = CodecsL( aStream );

    CMceComCodec* codec = NULL;

    CMceComCodec::TIterator codecs( allCodecs );

    RArray<TUint> payloadTypesInMediaLine;

    CleanupClosePushL( payloadTypesInMediaLine );

    User::LeaveIfError( DecodeFormatList( aMediaLine, payloadTypesInMediaLine ) );

    RPointerArray< CSdpFmtAttributeField >& formatLines =  

                                            aMediaLine.FormatAttributeFields();

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

		{

		CSdpFmtAttributeField* formatLine = formatLines[ i ];

        if ( formatLine->Attribute() == 

                    SDP_STRING( SdpCodecStringConstants::EAttributeRtpmap ) )

            //codec

            {

            TPtrC8 fmtpVal = GetCorrespondingFmtpLineL( aMediaLine, *formatLine );

            MCE_ITERATOR_FIND_NEXT( 

                codecs, codec, 

                codec->Decodes( formatLine->Value(), fmtpVal ) );

            codecs.Reset();

            if ( !codec && aRole == EMceRoleOfferer )

                {

                // No exact match, do less strict matching for better interoperability

                MCE_ITERATOR_FIND_NEXT( 

                codecs, codec, 

                codec->Decodes( formatLine->Value(), fmtpVal, EFalse ) );

                codecs.Reset();

                }

            if ( codec )

                {

                MCEMM_DEBUG_SVALUE("decoding codec", codec->iSdpName )

                const TDesC8& payloadTypeInRtpMap = formatLine->Format();

                TUint rtpMapPT = ConvertDesToUintL( payloadTypeInRtpMap );

                TInt val = payloadTypesInMediaLine.Find( rtpMapPT );

                if ( val != KErrNotFound )

                    {

                    TUint payload = ConvertDesToUintL( formatLine->Format() );

                    if ( !IsPayloadTypeSupported( codec->iSdpName, payload ) ) 

                    	{

						// not supported payload, ignore this codec

                    	continue;

                    	}

                    if ( !codec->iIsNegotiated )

                        {

                        codec->iPayloadType = payload;

                        }

                    codec->iIsNegotiated = ETrue;   

                    //decode media attributes

                    DecodeMediaAttributesL( aMediaLine, *codec, *formatLine );

                    decoded++;

                    }

                else

                    {

                    // Discarding as there was no matching pt in medialine for

                    // this rtmpmap line

                    codec->iIsNegotiated = EFalse;

                    if ( aStream.BoundStream() )

                        {

                        CMceComCodec* sync = NULL;

                        sync = aStream.BoundStreamL().FindCodecL( *codec );

                        if ( sync )

                            {

                            sync->iIsNegotiated = EFalse; 

                            }

                        }

                    }

                }

            else if ( aRole == EMceRoleAnswerer )

                {

                if ( DecodeRtpmapLineL( *formatLine, aMediaLine, aStream, fmtpVal ) )

                    {

                    decoded++;