/*

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

*

*/

// INCLUDE FILES

#include <delimitedpathsegment8.h>

#include "mmcccodecamrwb.h"

#include "mccuids.hrh"

#include "mmccinterfacelogs.h"

// CONSTANTS

const TInt KUndefinedMode( -1 );

const TInt KMaxModeSetValue( 9 );

const TInt KNotSet = -1;

const TInt KNumValue2 = 2;

// MODULE DATA STRUCTURES

const TUint8 KAmrKAPayloadSize = 6;

const TUint8 KAmrKeepAlivePayload[KAmrKAPayloadSize] = 

    { 

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

    };

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

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

// CMccCodecAmrWb::CMccCodecAmrWb

// default constructor

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

//

CMccCodecAmrWb::CMccCodecAmrWb() : CMccCodecAMR()

    {

    iBitrateMask = KMccAllowedAmrWbBitrateAll;

    iMaxRed = KNotSet;

    iDefaultBitrateMask = KMccAllowedAmrWbBitrateAll;

    iDefaultBitrate = KAmrWbBitrate2385;

    iAdditionalInfoMask = KMccAllowedAmrWbAdditionalInfo;

    iMaxModeSetVal = KMaxModeSetValue;

    }

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

// CMccCodecAmrWb::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMccCodecAmrWb::ConstructL( )

    {

    __INTERFACE( "CMccCodecAmrWb::ConstructL" )      

    iSdpName.Copy( KAMRWbSdpName );

    iKeepAliveData.Copy( KAmrKeepAlivePayload );

    iFmtpAttr = HBufC8::NewL( 1 );

    TPtr8 ptr = iFmtpAttr->Des();

    ptr.Append( KNullDesC );

    iFourCC = KMccFourCCIdAMRWB;

    SetSamplingFreq( KAmrWbSamplingFreq );

    EnableVAD( EFalse );

    iHwFrameTime = KAMRDefaultHwFrameTime; // default 20ms

    iFrameSize = KAmrWbDefaultFrameSize;

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

    SetPTime( KAMRDefaultPTime ); // default 20ms 

    SetBitrate( KAmrWbBitrate2385 ); // max bitrate

    SetPayloadType( KDefaultAmrWbPT );

    SetCodecMode( EBandwidthEfficient );

    iNumOfChannels = 1;

    iPayloadFormatEncoder = KImplUidAmrPayloadFormatEncode;

    iPayloadFormatDecoder = KImplUidAmrPayloadFormatDecode;

    __INTERFACE( "CMccCodecAmrWb::ConstructL, exit" )      

    }

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

// CMccCodecAmrWb::NewL

// Static constructor.

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

//

CMccCodecAmrWb* CMccCodecAmrWb::NewL()

    {

    CMccCodecAmrWb* self = new (ELeave) CMccCodecAmrWb;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); 

    return self;

    }

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

// CMccCodecAmrWb::~CMccCodecAmrWb

// Destructor

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

//

CMccCodecAmrWb::~CMccCodecAmrWb()

    {

    __INTERFACE( "CMccCodecAmrWb::~CMccCodecAmrWb" )      

    }

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

// CMccCodecAmrWb::GetBitrateModeSet

// Get the mode from the bitrate

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

//

TInt CMccCodecAmrWb::GetBitrateModeSet( TUint aBitrate )

    {

    __INTERFACE( "CMccCodecAmrWb::GetBitrateModeSet" )      

    TInt mode( KUndefinedMode );

    switch ( aBitrate )

        {

        case KAmrWbBitrate660:

            {

            mode = KAMRMode0;

            break;

            }

        case KAmrWbBitrate885:

            {

            mode = KAMRMode1;

            break;

            }

        case KAmrWbBitrate1265:

            {

            mode = KAMRMode2;

            break;

            }

        case KAmrWbBitrate1425:

            {

            mode = KAMRMode3;

            break;

            }

        case KAmrWbBitrate1585:

            {

            mode = KAMRMode4;

            break;

            }

        case KAmrWbBitrate1825:

            {

            mode = KAMRMode5;

            break;

            }

        case KAmrWbBitrate1985:

            {

            mode = KAMRMode6;

            break;

            }

        case KAmrWbBitrate2305:

            {

            mode = KAMRMode7;

            break;

            }

        case KAmrWbBitrate2385:

            {

            mode = KAMRMode8;

            break;

            }

        default:

            {

            break;

            }                

        }

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

    return mode;

    }

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

// CMccCodecAmrWb::SetBitrateModeSet

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

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

//

void CMccCodecAmrWb::SetBitrateModeSet( TUint aModeSet )

    {

    __INTERFACE( "CMccCodecAmrWb::SetBitrateModeSet" )      

    switch ( aModeSet )

        {

        case KAMRMode0:

            {

            SetBitrate( KAmrWbBitrate660 );

            break;

            }

        case KAMRMode1:

            {

            SetBitrate( KAmrWbBitrate885 );

            break;

            }

        case KAMRMode2:

            {

            SetBitrate( KAmrWbBitrate1265 );

            break;

            }

        case KAMRMode3:

            {

            SetBitrate( KAmrWbBitrate1425 );

            break;

            }

        case KAMRMode4:

            {

            SetBitrate( KAmrWbBitrate1585 );

            break;

            }

        case KAMRMode5:

            {

            SetBitrate( KAmrWbBitrate1825 );

            break;

            }

        case KAMRMode6:

            {

            SetBitrate( KAmrWbBitrate1985 );

            break;

            }

        case KAMRMode7:

            {

            SetBitrate( KAmrWbBitrate2305 );

            break;

            }

        case KAMRMode8:

            {

            SetBitrate( KAmrWbBitrate2385 );

            break;

            }

        default:

            {

            SetBitrate( KAmrWbBitrate660 );

            break;

            }

        }

    __INTERFACE( "CMccCodecAmrWb::SetBitrateModeSet, exit" )      

    }

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

// CMccCodecAmrWb::GetBitrateMaskFromMode

// Get the bitrate mask from the mode

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

//

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

    {

    __INTERFACE( "CMccCodecAmrWb::GetBitrateMaskFromMode" )          

    switch ( aMode )

        {

        case KAMRMode0:

            {

            aBitrateMask = KMccAllowedAmrWbBitrate660;

            break;

            } 

        case KAMRMode1:

            {

            aBitrateMask = KMccAllowedAmrWbBitrate885;

            break;

            }

        case KAMRMode2:

            {

            aBitrateMask = KMccAllowedAmrWbBitrate1265;

            break;

            }

        case KAMRMode3:

            {

            aBitrateMask = KMccAllowedAmrWbBitrate1425;

            break;

            }

        case KAMRMode4:

            {

            aBitrateMask = KMccAllowedAmrWbBitrate1585;

            break;

            }

        case KAMRMode5:

            {

            aBitrateMask = KMccAllowedAmrWbBitrate1825;

            break;

            }

        case KAMRMode6:

            {

            aBitrateMask = KMccAllowedAmrWbBitrate1985;

            break;

            }

        case KAMRMode7:

            {

            aBitrateMask = KMccAllowedAmrWbBitrate2305;

            break;

            }

        case KAMRMode8:

            {

            aBitrateMask = KMccAllowedAmrWbBitrateAll;

            break;

            }

        default:

            {

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

            return KErrNotFound; 

            }                

        }

    __INTERFACE( "CMccCodecAmrWb::GetBitrateMaskFromMode, exit" )          

    return KErrNone;

    }

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

// CMccCodecAmrWb::SetBitrate

// Sets the bitrate used with AMR codec.

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

//

TInt CMccCodecAmrWb::SetBitrate( TUint aBitrate )

    {

    TBool isValid( ETrue );

    switch ( aBitrate )

        {

        case KAmrWbBitrate660:

            break;

        case KAmrWbBitrate885:

            break;

        case KAmrWbBitrate1265:

            break;

        case KAmrWbBitrate1425:

            break;

        case KAmrWbBitrate1585:

            break;

        case KAmrWbBitrate1825:

            break;

        case KAmrWbBitrate1985:

            break;

        case KAmrWbBitrate2305:

            break;

        case KAmrWbBitrate2385:

            break;

        default:

            isValid = EFalse;

            break;

        }

    if ( isValid )

        {

        iBitrate = aBitrate;

        return KErrNone;

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMccCodecAmrWb::SetBitrateFromBitrateMask

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

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

//

TInt CMccCodecAmrWb::SetBitrateFromBitrateMask( TUint aBitrateMask )

    {

    if ( aBitrateMask & KMccAllowedAmrWbModeChangePeriod2 )

        {

        SetModeChangePeriod( KNumValue2 );

        }

    if ( aBitrateMask & KMccAllowedAmrWbModeChangeNeighbor1 )

        {

        SetModeChangeNeighbor( ETrue );

        }

    if( aBitrateMask & KMccAllowedAmrWbBitrate2385 )

        {

        SetBitrate( KAmrWbBitrate2385 );

        return KErrNone;

        }

    else if( aBitrateMask & KMccAllowedAmrWbBitrate2305 )

        {

        SetBitrate( KAmrWbBitrate2305 );

        return KErrNone;

        }

    else if( aBitrateMask & KMccAllowedAmrWbBitrate1985 )

        {

        SetBitrate( KAmrWbBitrate1985 );

        return KErrNone;

        }   

    else if( aBitrateMask & KMccAllowedAmrWbBitrate1825 )

        {

        SetBitrate( KAmrWbBitrate1825 );

        return KErrNone;

        }   

    else if( aBitrateMask & KMccAllowedAmrWbBitrate1585 )

        {

        SetBitrate( KAmrWbBitrate1585 );

        return KErrNone;

        }   

    else if( aBitrateMask & KMccAllowedAmrWbBitrate1425 )

        {

        SetBitrate( KAmrWbBitrate1425 );

        return KErrNone;

        }

    else if( aBitrateMask & KMccAllowedAmrWbBitrate1265 )

        {

        SetBitrate( KAmrWbBitrate1265 );

        return KErrNone;

        }  

    else if( aBitrateMask & KMccAllowedAmrWbBitrate885 )

        {

        SetBitrate( KAmrWbBitrate885 );

        return KErrNone;

        }

    else if( aBitrateMask & KMccAllowedAmrWbBitrate660 )

        {

        SetBitrate( KAmrWbBitrate660 );

        return KErrNone;

        }

    else

        {

        return KErrArgument;    

        }

    }

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

// CMccCodecAmrWb::SetSamplingFreq

// Sets the sampling frequency. 

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

//

TInt CMccCodecAmrWb::SetSamplingFreq( TUint32 aSamplingFreq )

    {

    if ( KAmrWbSamplingFreq == aSamplingFreq )

        {

        iSamplingFreq = aSamplingFreq;

        return KErrNone;

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMccCodecAmrWb::SetSdpName

// Sets the SDP name

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

TInt CMccCodecAmrWb::SetSdpName( const TDesC8& aSdpName )

    {

    if ( !aSdpName.CompareF( KAMRWbSdpName ) )

        {

        iSdpName.Copy( aSdpName );

        }

    else 

        {

        return KErrNotSupported;

        }

    return KErrNone;

    }

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

// CMccCodecAmrWb::SetAllowedBitrates

// Set allowed bitrates

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

//

TInt CMccCodecAmrWb::SetAllowedBitrates( TUint aBitrateMask )

    {

    //Confirm that the bitrate mask is valid

    //I.e. after all the valid bitrates are set to zero the value should be zero

    if ( (aBitrateMask >> 16 ) > 0 )

        {

        return KErrArgument;

        }

    else

        {

        /*

        In the future the allowed bitrates will be fetched from the codec

        I.e. the KMccAllowedAmrNbBitrateAll will be changed to the bitrates

        supported by the codec

        */

        SetBitrateMask( KMccAllowedAmrWbBitrateAll & aBitrateMask );

        SetBitrateMaskAdditionalInfo( aBitrateMask );

        SetBitrateFromBitrateMask( iBitrateMask );

        }

    return KErrNone;

    }

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

// CMccCodecAmrWb::GetAllowedBitratesArrayL

// Get allowed bitrates in an array

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

//

TInt CMccCodecAmrWb::GetAllowedBitratesArrayL( RArray<TUint>& aBitratesArray )

    {

    if( iBitrateMask & KMccAllowedAmrWbBitrate660 )

        {

        User::LeaveIfError( aBitratesArray.Append(  KAmrWbBitrate660 ) );

        }

    if( iBitrateMask & KMccAllowedAmrWbBitrate885 )

        {

        User::LeaveIfError( aBitratesArray.Append( KAmrWbBitrate885 ) );

        }

    if( iBitrateMask & KMccAllowedAmrWbBitrate1265 )

        {

        User::LeaveIfError( aBitratesArray.Append( KAmrWbBitrate1265 ) );

        }

    if( iBitrateMask & KMccAllowedAmrWbBitrate1425 )

        {

        User::LeaveIfError( aBitratesArray.Append( KAmrWbBitrate1425 ) );

        }

    if( iBitrateMask & KMccAllowedAmrWbBitrate1585 )

        {

        User::LeaveIfError( aBitratesArray.Append( KAmrWbBitrate1585 ) );

        }

    if( iBitrateMask & KMccAllowedAmrWbBitrate1825 )

        {

        User::LeaveIfError( aBitratesArray.Append( KAmrWbBitrate1825 ) );

        }

    if( iBitrateMask & KMccAllowedAmrWbBitrate1985 )

        {

        User::LeaveIfError( aBitratesArray.Append( KAmrWbBitrate1985 ) );

        }

    if( iBitrateMask & KMccAllowedAmrWbBitrate2305 )