/*

* Copyright (c) 2002-2004 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:    MCC DTMF CodecInformation

*

*/

// INCLUDE FILES

#include "mmcccodecdtmf.h"

#include "mccuids.hrh"

#include "mmccinterfacelogs.h"

#include "mccinternalcodecs.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

const TUint KDefaultSamplingFreq = 8000;

const TInt KMaxFmtpAttrLength( 50 );

const TText8 KCharComma = ',';

const TText8 KCharHyphen = '-';

const TText8 KCharSpace = ' ';

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CMccCodecDTMF::CMccCodecDTMF

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMccCodecDTMF::CMccCodecDTMF() : CMccCodecInformation()

    {

    }

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

// CMccCodecDTMF::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMccCodecDTMF::ConstructL()

    {

    iSdpName.Copy( KTelephoneEvent );

    iFmtpAttr = HBufC8::NewL( KMaxFmtpAttrLength );

    SetPTime( KDTMFPTime );

    SetPayloadType( KDefaultDtmfPT );

    SetCodecMode( EDTMFModeEvent );

    SetSamplingFreq( KDefaultSamplingFreq );

    SetAllowedBitrates( KMccAllowedDtmfNumberALL );

    iFourCC = KMccFourCCIdDTMF;

    iPayloadFormatEncoder = KImplUidDTMFPayloadFormatEncode;

    iPayloadFormatDecoder = KImplUidDTMFPayloadFormatDecode;

    }

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

// CMccCodecDTMF::NewL

// Two-phased constructor.

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

//

CMccCodecDTMF* CMccCodecDTMF::NewL()

    {

    CMccCodecDTMF* self = new( ELeave ) CMccCodecDTMF;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMccCodecDTMF::~CMccCodecDTMF

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

//

CMccCodecDTMF::~CMccCodecDTMF()

    {

    }

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

// CMccCodecDTMF::RequireSignalling

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

//

TBool CMccCodecDTMF::RequireSignalling(

    const CMccCodecInformation& aCandidate ) const      

    {

    __INTERFACE( "CMccCodecDTMF::RequireSignalling" )

    TBool ret = EFalse;

    if ( iPTime != aCandidate.PTime() )

        {

        __INTERFACE( "CMccCodecDTMF::RequireSignalling, PTime changed" )

        ret = ETrue;

        }

    if ( iMaxPTime != aCandidate.MaxPTime() )

        {

        __INTERFACE( "CMccCodecDTMF::RequireSignalling, MaxPTime changed" )

        ret = ETrue;

        }

    if ( iPayloadType != aCandidate.PayloadType() )

        {

        __INTERFACE( "CMccCodecDTMF::RequireSignalling, PayloadType changed" )

        ret = ETrue;

        }

    if ( iCodecMode != aCandidate.CodecMode() )

        {

        __INTERFACE( "CMccCodecDTMF::RequireSignalling, CodecMode changed" )

        ret = ETrue;

        }      

    __INTERFACE_INT1( "CMccCodecDTMF::RequireSignalling, exit with", ret )

    return ret;          

    }

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

// CMccCodecDTMF::SetBitrate

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

//

TInt CMccCodecDTMF::SetBitrate( TUint aBitrate )

    {

    return ( aBitrate > 0 ) ? KErrNotSupported : KErrNone;

    }

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

// CMccCodecDTMF::SetSamplingFreq

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

//

TInt CMccCodecDTMF::SetSamplingFreq( TUint32 aSamplingFreq )

    {

    return ( KDefaultSamplingFreq != aSamplingFreq ) ? KErrNotSupported : KErrNone;

    }

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

// CMccCodecDTMF::SetSdpName

// Sets the SDP name

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

//

TInt CMccCodecDTMF::SetSdpName( const TDesC8& aSdpName )

    {

    if ( 0 == aSdpName.CompareF( KTelephoneEvent ) )

        {

        iSdpName.Copy( aSdpName );

        }

    else 

        {

        return KErrNotSupported;

        }

    return KErrNone;

    }

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

// CMccCodecDTMF::PayloadType

// Sets the payload type

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

//

TInt CMccCodecDTMF::SetPayloadType( TUint8 aPayloadType )

    {

    if ( aPayloadType < KMinDynamicPT ||

         aPayloadType > KMaxPayloadType ) 

        {

        return KErrNotSupported;

        }

    else 

        {

        iPayloadType = aPayloadType;

        }

    return KErrNone;

    }

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

// CMccCodecDTMF::SetCodecMode

// Sets the codec mode.

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

//

TInt CMccCodecDTMF::SetCodecMode( TCodecMode aCodecMode )

    {

	if ( EDTMFModeEvent == aCodecMode )

	    {

	    iCodecMode = aCodecMode;

	    return KErrNone;

	    }

    else if( EDTMFModeInband == aCodecMode )

        {

        iCodecMode = aCodecMode;

        return KErrNone;

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMccCodecDTMF::SetAllowedBitrates

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

//    

TInt CMccCodecDTMF::SetAllowedBitrates( TUint aBitrateMask )

    {

    if ( (aBitrateMask >> 16 ) > 0 )

        {

        return KErrArgument;

        }

    else

        {

        iBitrateMask = KMccAllowedDtmfNumberALL;

        iBitrateMask &= aBitrateMask;

        }

    return KErrNone;

    }

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

// CMccCodecDTMF::EnableVAD

// Enable / Disable VAD

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

//

TInt CMccCodecDTMF::EnableVAD( TBool aEnableVAD ) 

    {

    return aEnableVAD ? KErrNotSupported : KErrNone;

    }

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

// CMccCodecDTMF::SetPTime

// Set PTime

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

//

TInt CMccCodecDTMF::SetPTime( TUint aPTime )

    {

    if ( ( aPTime <= 200 ) && (( aPTime % 10 )  == 0 ))

        {

        iPTime = aPTime;

        return KErrNone;    

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMccCodecDTMF::SetMaxPTime

// Set Max PTime

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

//

TInt CMccCodecDTMF::SetMaxPTime( TUint aMaxPTime )

    {

    if ( ( aMaxPTime <= 200 ) && (( aMaxPTime % 10 )  == 0 ))

        {

        iMaxPTime = aMaxPTime;

        return KErrNone;    

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMccCodecDTMF::CloneDefaultsL

// Make a default setting clone from this DTMF codec

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

//

CMccCodecInformation* CMccCodecDTMF::CloneDefaultsL()

    {

    return CMccCodecDTMF::NewL();

    }

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

// CMccCodecDTMF::CloneDetailedL

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

//

CMccCodecInformation* CMccCodecDTMF::CloneDetailedL()

    {

    CMccCodecDTMF* newCodec = CMccCodecDTMF::NewL();

    CleanupStack::PushL( newCodec );

    newCodec->SetBitrate( this->Bitrate() );

    newCodec->SetAllowedBitrates( this->AllowedBitrates() );

    newCodec->SetCodecMode( this->CodecMode() );

    newCodec->SetMaxPTime( this->MaxPTime() );

    newCodec->SetPayloadType( this->PayloadType() );

    newCodec->SetPTime( this->PTime() );

    newCodec->SetSamplingFreq( this->SamplingFreq() );

    newCodec->SetSdpName( this->SdpName() );  

    CleanupStack::Pop( newCodec );

    return newCodec;

    }

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

// CMccCodecDTMF::GetFmtpL

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

// 

TDesC8& CMccCodecDTMF::GetFmtpL()

    {

    __INTERFACE( "CMccCodecDTMF::GetFmtpL" )      

    delete iFmtpAttr;

    iFmtpAttr = NULL;

    CreateFmtpAttrListL();

    __INTERFACE( "CMccCodecDTMF::GetFmtpL, exit" ) 

    return *iFmtpAttr;    

    }

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

// CMccCodecDTMF::CreateFmtpAttrListL

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

//  

void CMccCodecDTMF::CreateFmtpAttrListL()

    {

    __INTERFACE( "CMccCodecDTMF::CreateFmtpAttrListL" )

    RArray<TUint> toneNumbers;

    CleanupClosePushL( toneNumbers );

    GetAllowedToneNumbersArrayL( toneNumbers );

    CreateFmtpAttrListL( toneNumbers );

    CleanupStack::PopAndDestroy(); // toneNumbers

    __INTERFACE( "CMccCodecDTMF::CreateFmtpAttrListL, exit" )

    }

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

// CMccCodecDTMF::ParseFmtpAttrL

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

//       

TBool CMccCodecDTMF::ParseFmtpAttrL( const TDesC8& aFmtp )

    {

    __INTERFACE( "CMccCodecDTMF::ParseFmtpAttrL" )      

    __INTERFACE_STR( "CMccCodecDTMF::ParseFmtpAttrL, fmtpValue=", aFmtp )

    /*

    a=fmtp:<format> <list of values>

    The list of values consists of comma-separated elements, which can be

    either a single decimal number or two decimal numbers separated by a

    hyphen (dash), where the second number is larger than the first. No

    whitespace is allowed between numbers or hyphens. The list does not

    have to be sorted.

    */

    TBool updated = EFalse;

    if ( aFmtp.Length() > 0 )

        {

        // white space is not allowed 

        if ( aFmtp.Locate( KCharSpace ) >= 0 )

            {

            User::Leave( KErrArgument );  

            }

        CPtrC8Array* tokens = TokenizeL( aFmtp, KCharComma );

        CleanupStack::PushL( tokens );

        // Mask will be updated while parsing

        iBitrateMask = 0;

        updated = EncodeTokensL( *tokens );

        CleanupStack::PopAndDestroy( tokens );

        }

    __INTERFACE( "CMccCodecDTMF::ParseFmtpAttrL, exit" )   

    return updated;

    }

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

// CMccCodecDTMF::TokenizeL

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

//  

CPtrC8Array* CMccCodecDTMF::TokenizeL( const TDesC8& aValue,

                                       const TChar& aSeparator )

    {

    __INTERFACE( "CMccCodecDTMF::TokenizeLC" )      

	__ASSERT_ALWAYS ( aValue.Length() > 0, User::Leave(KErrArgument) ); 

	__ASSERT_ALWAYS ( aSeparator == KCharComma, User::Leave(KErrArgument) ); 

    CPtrC8Array* tokens = new (ELeave) CPtrC8Array(1);  

    CleanupStack::PushL( tokens );

	TLex8 lex(aValue);

	TChar chr = lex.Get();

    TInt previuosCommaPos = -1;

    TInt currentCommaPos = 0;

	while ( chr )

		{

		// seperator (comma ',') found

		if (chr == aSeparator)

			{

		    AddTokenL( *tokens, aValue, previuosCommaPos+1, currentCommaPos-1 );

    		previuosCommaPos = currentCommaPos; 

			}

    	chr = lex.Get();

        currentCommaPos++;

		}

    // the token is last one or first one without comma found

    if ( ( currentCommaPos - previuosCommaPos ) > 1 )

        {

        AddTokenL( *tokens, aValue, previuosCommaPos+1, currentCommaPos-1 );

        }

    else // token error

        {

        User::Leave( KErrArgument );   

        }

    CleanupStack::Pop( tokens );

    __INTERFACE( "CMccCodecDTMF::TokenizeLC, exit" )      

    return tokens;

    }

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

// CMccCodecDTMF::AddTokenL

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

//  

void CMccCodecDTMF::AddTokenL ( CPtrC8Array& aTokenArray, 

                                const TDesC8& aValue, 

                                TInt aTokenStartPos,

                                TInt aTokenEndPos )

    {

    __INTERFACE( "CMccCodecDTMF::AddTokenL" )      

	__ASSERT_ALWAYS ( aTokenStartPos >= 0, User::Leave(KErrArgument) ); 

    __ASSERT_ALWAYS ( aTokenEndPos >= 0, User::Leave(KErrArgument) ); 

    __ASSERT_ALWAYS ( aTokenStartPos <= aTokenEndPos, User::Leave(KErrArgument) ); 

    TUint8 tokenlength = aTokenEndPos - aTokenStartPos + 1;

	TPtrC8 token ( aValue.Mid(  aTokenStartPos , tokenlength ) );

	aTokenArray.AppendL(token);

	__INTERFACE( "CMccCodecDTMF::AddTokenL, exit" )      

    }

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

// CMccCodecDTMF::EncodeTokensL

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

//  

TBool CMccCodecDTMF::EncodeTokensL( MDesC8Array& aTokenArray )

    {

    __INTERFACE( "CMccCodecDTMF::EncodeTokensL" )      

    __ASSERT_ALWAYS ( aTokenArray.MdcaCount() > 0, User::Leave(KErrArgument) ); 

    TBool updated = EFalse;

    for ( TInt i=0; i < aTokenArray.MdcaCount(); i++ )

        {

        if ( ParseTokenL(aTokenArray.MdcaPoint( i )) ) 

            {

            updated = ETrue;   

            }

        }

    __INTERFACE( "CMccCodecDTMF::EncodeTokensL, exit" )      

    return updated;

    }

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

// CMccCodecDTMF::ParseTokenL

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

//       

TBool CMccCodecDTMF::ParseTokenL( const TDesC8& aValue )

    {

    __INTERFACE( "CMccCodecDTMF::ParseTokenL" )      

    __ASSERT_ALWAYS ( aValue.Length() > 0, User::Leave(KErrArgument) ); 

    TBool updated = EFalse;

    TBufC8<256> value(aValue);

    _LIT8( KFMTPEVENTS, "events=" );

    TBufC8<32> value2(KFMTPEVENTS);

    TInt match = value.Find( KFMTPEVENTS );

    if( KErrNotFound != match )

	    {

        value = value.Mid( match + value2.Length() );

		}