/*

* 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 AMR CodecInformation

*

*/

// INCLUDE FILES

#include <delimitedpathsegment8.h>

#include "mmcccodecamr.h"

#include "mccuids.hrh"

#include "mmccinterfacelogs.h"

// CONSTANTS

const TInt KUndefinedMode( -1 );

const TInt KMaxModeSetValue( 8 );

const TInt KNotSet = -1;

const TInt KNumValue1 = 1;

const TInt KNumValue2 = 2;

// MODULE DATA STRUCTURES

const TUint8 KAmrKAPayloadSize = 6;

const TUint8 KAmrKeepAlivePayload[KAmrKAPayloadSize] = 

    { 

    0xF4, 0x00, 0x00, 0x00, 0x00, 0x00

    };

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

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

// CMccCodecAMR::CMccCodecAMR

// default constructor

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

//

CMccCodecAMR::CMccCodecAMR() : CMccCodecInformation()

    {

    iBitrateMask = KMccAllowedAmrNbBitrateAll;

    iMaxRed = KNotSet;

    iDefaultBitrateMask = KMccAllowedAmrNbBitrateAll;

    iDefaultBitrate = KAmrNbBitrate122;

    iAdditionalInfoMask = KMccAllowedAmrAdditionalInfo;

    iMaxModeSetVal = KMaxModeSetValue;

    }

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

// CMccCodecAMR::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMccCodecAMR::ConstructL( )

    {

    __INTERFACE( "CMccCodecAMR::ConstructL" )      

    iSdpName.Copy( KAMRSdpName );

    iKeepAliveData.Copy( KAmrKeepAlivePayload );

    iFmtpAttr = HBufC8::NewL( 1 );

    TPtr8 ptr = iFmtpAttr->Des();

    ptr.Append( KNullDesC );

    iFourCC = KMccFourCCIdAMRNB;

    SetSamplingFreq( KAmrNbSamplingFreq );

    EnableVAD( EFalse );

    iHwFrameTime = KAMRDefaultHwFrameTime; // default 20ms

    iFrameSize = KAMRDefaultFrameSize;

    SetMaxPTime( KAMRDefaultMaxPTime ); // recommended "limit" 200ms

    SetPTime( KAMRDefaultPTime ); // default 20ms 

    SetBitrate( KAmrNbBitrate122 ); // max bitrate

    SetPayloadType( KDefaultAmrNbPT );

    SetCodecMode( EBandwidthEfficient );

    iNumOfChannels = 1;

    iPayloadFormatEncoder = KImplUidAmrPayloadFormatEncode;

    iPayloadFormatDecoder = KImplUidAmrPayloadFormatDecode;

    __INTERFACE( "CMccCodecAMR::ConstructL, exit" )      

    }

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

// CMccCodecAMR::NewL

// Static constructor.

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

//

CMccCodecAMR* CMccCodecAMR::NewL()

    {

    CMccCodecAMR* self = new (ELeave) CMccCodecAMR;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); 

    return self;

    }

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

// CMccCodecAMR::~CMccCodecAMR

// Destructor

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

//

CMccCodecAMR::~CMccCodecAMR()

    {

    __INTERFACE( "CMccCodecAMR::~CMccCodecAMR" )      

    }

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

// CMccCodecAMR::GetFmtpL

// Gets the fmtp attribute

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

//

TDesC8& CMccCodecAMR::GetFmtpL()

    {

    __INTERFACE( "CMccCodecAMR::GetFmtpL" )      

    if ( iFmtpAttr )

        {

        delete iFmtpAttr;

        iFmtpAttr = NULL;

        }

    if( iBitrateMask )

        {

        RArray<TUint> array;

        CleanupClosePushL( array );

        if( GetAllowedBitratesArrayL( array ) == KErrNone )

            {

            CreateFmtpAttrListL( array );    

            }

        else

            {

            CreateFmtpAttrListL();        

            }

        CleanupStack::Pop( &array );

        array.Close();

        }

    else

        {

        CreateFmtpAttrListL();    

        }

    __INTERFACE_STR( "CMccCodecAMR::GetFmtpL", *iFmtpAttr);     

    return *iFmtpAttr;    

    }

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

// CMccCodecAMR::GetBitrateModeSet

// Get the mode from the bitrate

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

//

TInt CMccCodecAMR::GetBitrateModeSet( TUint aBitrate )

    {

    __INTERFACE( "CMccCodecAMR::GetBitrateModeSet" )      

    TInt mode( KUndefinedMode );

    switch ( aBitrate )

        {

        case KAmrNbBitrate475:

            {

            mode = KAMRMode0;

            break;

            }

        case KAmrNbBitrate515:

            {

            mode = KAMRMode1;

            break;

            }

        case KAmrNbBitrate590:

            {

            mode = KAMRMode2;

            break;

            }

        case KAmrNbBitrate670:

            {

            mode = KAMRMode3;

            break;

            }

        case KAmrNbBitrate740:

            {

            mode = KAMRMode4;

            break;

            }

        case KAmrNbBitrate795:

            {

            mode = KAMRMode5;

            break;

            }

        case KAmrNbBitrate102:

            {

            mode = KAMRMode6;

            break;

            }

        case KAmrNbBitrate122:

            {

            mode = KAMRMode7;

            break;

            }

        default:

            {

            break;

            }                

        }

    __INTERFACE_INT1( "CMccCodecAMR::GetBitrateModeSet, exit with mode", mode )      

    return mode;

    }

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

// CMccCodecAMR::SetBitrateModeSet

// Sets the bitrate used with AMR codec from the mode .

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

//

void CMccCodecAMR::SetBitrateModeSet( TUint aModeSet )

    {

    __INTERFACE( "CMccCodecAMR::SetBitrateModeSet" )      

    switch ( aModeSet )

        {

        case KAMRMode0:

            {

            SetBitrate( KAmrNbBitrate475 );

            break;

            }

        case KAMRMode1:

            {

            SetBitrate( KAmrNbBitrate515 );

            break;

            }

        case KAMRMode2:

            {

            SetBitrate( KAmrNbBitrate590 );

            break;

            }

        case KAMRMode3:

            {

            SetBitrate( KAmrNbBitrate670 );

            break;

            }

        case KAMRMode4:

            {

            SetBitrate( KAmrNbBitrate740 );

            break;

            }

        case KAMRMode5:

            {

            SetBitrate( KAmrNbBitrate795 );

            break;

            }

        case KAMRMode6:

            {

            SetBitrate( KAmrNbBitrate102 );

            break;

            }

        case KAMRMode7:

            {

            SetBitrate( KAmrNbBitrate122 );

            break;

            }

        default:

            {

            SetBitrate( KAmrNbBitrate475 );

            break;

            }

        }

    __INTERFACE( "CMccCodecAMR::SetBitrateModeSet, exit" )      

    }

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

// CMccCodecAMR::GetBitrateMaskFromMode

// Get the bitrate mask from the mode

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

//

TInt CMccCodecAMR::GetBitrateMaskFromMode( TUint aMode, TUint& aBitrateMask  )

    {

    __INTERFACE( "CMccCodecAMR::GetBitrateMaskFromMode" )          

    switch ( aMode )

        {

        case KAMRMode0:

            {

            aBitrateMask = KMccAllowedAmrNbBitrate475;

            break;

            }

        case KAMRMode1:

            {

            aBitrateMask = KMccAllowedAmrNbBitrate515;

            break;

            }

        case KAMRMode2:

            {

            aBitrateMask = KMccAllowedAmrNbBitrate590;

            break;

            }

        case KAMRMode3:

            {

            aBitrateMask = KMccAllowedAmrNbBitrate670;

            break;

            }

        case KAMRMode4:

            {

            aBitrateMask = KMccAllowedAmrNbBitrate740;

            break;

            }

        case KAMRMode5:

            {

            aBitrateMask = KMccAllowedAmrNbBitrate795;

            break;

            }

        case KAMRMode6:

            {

            aBitrateMask = KMccAllowedAmrNbBitrate102;

            break;

            }

        case KAMRMode7:

            {

            aBitrateMask = KMccAllowedAmrNbBitrate122;

            break;

            }

        default:

            {

            __INTERFACE( "CMccCodecAMR::GetBitrateMaskFromMode, exit KErrNotFound" )          

            return KErrNotFound; 

            }                

        }

    __INTERFACE( "CMccCodecAMR::GetBitrateMaskFromMode, exit" )          

    return KErrNone;

    }

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

// CMccCodecAMR::CreateFmtpModeSet

// Creates the mode-set value of the FMTP according to the bitrates

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

//

TBool CMccCodecAMR::CreateFmtpModeSet( TDes8& aBuf,

                                       const RArray<TUint>& aBitrates )

    {

    __INTERFACE( "CMccCodecAMR::CreateFmtpModeSet" )          

    TInt tempMode;

    TBool modeSetStringAdded( EFalse );

    _LIT8( KTxtTempMode, "%d" );

    _LIT8( KTxtComma, "," );

    TInt count( aBitrates.Count() );

    if ( count > iMaxModeSetVal )

        {

        return modeSetStringAdded;

        }

    for ( TInt i = 0; i < count; i++ )

        {

        tempMode = this->GetBitrateModeSet( aBitrates[i] );

        // Do not modify the buffer until we have a recognized mode value

        if ( tempMode >= 0 )

            {

            if ( !modeSetStringAdded )

                {

                // Insert the mode string before the first value

                aBuf.Append( KTxtModeSet ); // "mode-set="

                modeSetStringAdded = ETrue;

                // Also clear the bitrate mask

                SetBitrateMask( 0, ETrue );

                }

            else

                {

                // Insert a comma before all other values

                aBuf.Append( KTxtComma );

                }

            // Update the bitrate mask

            TUint currentMask( 0 );

            GetBitrateMaskFromMode( tempMode, currentMask );

            SetBitrateMask( ( iBitrateMask | currentMask ), ETrue );

            // Update the FMTP string

            aBuf.AppendFormat( KTxtTempMode, tempMode );

            }

        }

    __INTERFACE( "CMccCodecAMR::CreateFmtpModeSet, exit" )          

    return modeSetStringAdded;

    }

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

// CMccCodecAMR::SetBitrate

// Sets the bitrate used with AMR codec.

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

//

TInt CMccCodecAMR::SetBitrate( TUint aBitrate )

    {

    TBool isValid( ETrue );

    switch ( aBitrate )

        {

        case KAmrNbBitrate475:

            break;

        case KAmrNbBitrate515:

            break;

        case KAmrNbBitrate590:

            break;

        case KAmrNbBitrate670:

            break;

        case KAmrNbBitrate740:

            break;

        case KAmrNbBitrate795:

            break;

        case KAmrNbBitrate102:

            break;

        case KAmrNbBitrate122:

            break;

        default:

            isValid = EFalse;

            break;

        }

    if ( isValid )

        {

        iBitrate = aBitrate;

        return KErrNone;

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMccCodecAMR::SetBitrateFromBitrateMask

// Sets the bitrate used with AMR codec from the bitrateMask.

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

//

TInt CMccCodecAMR::SetBitrateFromBitrateMask( TUint aBitrateMask )

    {

    if ( aBitrateMask & KMccAllowedModeChangePeriod2 )

        {

        SetModeChangePeriod( KNumValue2 );

        }

    if ( aBitrateMask & KMccAllowedModeChangeNeighbor1 )

        {

        SetModeChangeNeighbor( ETrue );

        }

    if( aBitrateMask & KMccAllowedAmrNbBitrate122 )

        {

        SetBitrate( KAmrNbBitrate122 );

        return KErrNone;

        }

    else if( aBitrateMask & KMccAllowedAmrNbBitrate102 )

        {

        SetBitrate( KAmrNbBitrate102 );

        return KErrNone;

        }

    else if( aBitrateMask & KMccAllowedAmrNbBitrate795 )

        {

        SetBitrate( KAmrNbBitrate795 );

        return KErrNone;

        }   

    else if( aBitrateMask & KMccAllowedAmrNbBitrate740 )

        {

        SetBitrate( KAmrNbBitrate740 );

        return KErrNone;

        }   

    else if( aBitrateMask & KMccAllowedAmrNbBitrate670 )

        {

        SetBitrate( KAmrNbBitrate670 );

        return KErrNone;

        }   

    else if( aBitrateMask & KMccAllowedAmrNbBitrate590 )

        {

        SetBitrate( KAmrNbBitrate590 );

        return KErrNone;

        }

    else if( aBitrateMask & KMccAllowedAmrNbBitrate515 )

        {

        SetBitrate( KAmrNbBitrate515 );

        return KErrNone;

        }  

    else if( aBitrateMask & KMccAllowedAmrNbBitrate475 )

        {

        SetBitrate( KAmrNbBitrate475 );

        return KErrNone;

        }

    else

        {

        return KErrArgument;    

        }

    }

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

// CMccCodecAMR::SetSamplingFreq

// Sets the sampling frequency. 

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

//

TInt CMccCodecAMR::SetSamplingFreq( TUint32 aSamplingFreq )

    {

    // AMR-WB is not supported yet

    if ( KAmrNbSamplingFreq == aSamplingFreq /* || KAmrWbSamplingFreq == aSamplingFreq */ )

        {

        iSamplingFreq = aSamplingFreq;

        return KErrNone;

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMccCodecAMR::SetSdpName

// Sets the SDP name