/*

* 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:    MCC Comfort Noise CodecInformation

*

*/

// INCLUDE FILES

#include "mmcccodeccn.h"

#include "mccuids.hrh"

#include "mmccinterfacelogs.h"

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

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

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

// CMccCodecCn::CMccCodecCn

// default constructor

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

//

CMccCodecCn::CMccCodecCn() : CMccCodecInformation()

    {

    }

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

// CMccCodecCn::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMccCodecCn::ConstructL()

    {

    iSdpName.Copy( KCnSdpName );

    iFmtpAttr = HBufC8::NewL( 1 );

    TPtr8 ptr = iFmtpAttr->Des();

    ptr.Append( KNullDesC );

    SetSamplingFreq( KCnSamplingFreq );

    EnableVAD( EFalse );

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

    SetPTime( KCnPTime ); // default 20ms 

    SetPayloadType( KCnPayloadType );  

    iFourCC = KMccFourCCIdCN;

    iCodecMode = ENothing;

    }

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

// CMccCodecCn::NewLC

// Static constructor.

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

//

CMccCodecCn* CMccCodecCn::NewL()

    {

    CMccCodecCn* self = new (ELeave) CMccCodecCn;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); 

    return self;

    }

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

// CMccCodecCn::~CMccCodecCn

// Destructor

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

//

CMccCodecCn::~CMccCodecCn()

    {

    }

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

// CMccCodecCn::RequireSignalling

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

//

TBool CMccCodecCn::RequireSignalling(

    const CMccCodecInformation& aCandidate ) const      

    {

    __INTERFACE( "CMccCodecCn::RequireSignalling" )

    const CMccCodecCn& candidate = static_cast<const CMccCodecCn&>( aCandidate );

    TBool ret = EFalse;

    if ( iPTime != candidate.PTime() )

        {

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

        ret = ETrue;

        }

    if ( iMaxPTime != candidate.MaxPTime() )

        {

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

        ret = ETrue;

        }

    if ( iPayloadType != candidate.PayloadType() )

        {

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

        ret = ETrue;

        }

    if ( iCodecMode != candidate.CodecMode() )

        {

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

        ret = ETrue;

        }     

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

    return ret;          

    }

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

// CMccCodecCn::SetBitrate

// Sets the bitrate used with codec.

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

//

TInt CMccCodecCn::SetBitrate( TUint aBitrate )

    {

    iBitrate = aBitrate;

    return KErrNone;

    }

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

// CMccCodecCn::SetSamplingFreq

// Sets the sampling frequency. 

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

//

TInt CMccCodecCn::SetSamplingFreq( TUint32 aSamplingFreq )

    {

    iSamplingFreq = aSamplingFreq;

    return KErrNone;

    }

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

// CMccCodecCn::SetSdpName

// Sets the SDP name

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

TInt CMccCodecCn::SetSdpName( const TDesC8& aSdpName )

    {

    if ( !aSdpName.CompareF( KCnSdpName ) )

        {

        iSdpName.Copy( aSdpName );

        }

    else 

        {

        return KErrNotSupported;

        }

    return KErrNone;

    }

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

// CMccCodecCn::PayloadType

// Sets the payload type

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

TInt CMccCodecCn::SetPayloadType( TUint8 aPayloadType )

    {

    if ( aPayloadType == KCnPayloadType ||

         aPayloadType == KCnPayloadTypeReserved ) 

        {

        iPayloadType = aPayloadType;

        return KErrNone;

        }

    return KErrNotSupported;

    }

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

// CMccCodecCn::SetCodecMode

// Sets the codec mode

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

TInt CMccCodecCn::SetCodecMode( TCodecMode aCodecMode )

    {

    if ( ENothing == aCodecMode )

        {

        iCodecMode = aCodecMode;

        return KErrNone;

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMccCodecCn::EnableVAD

// 

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

TInt CMccCodecCn::EnableVAD( TBool aEnableVAD ) 

    {

    iEnableVAD = aEnableVAD;        

    return KErrNone;

    }    

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

// CMccCodecCn::SetPTime

//

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

//

TInt CMccCodecCn::SetPTime( TUint aPTime )

    {

    if ( aPTime && ( KMinPtime <= aPTime ) &&  ( aPTime <= KMaxPtime ) && 

        (( aPTime % KMinPtime )  == 0 ))

        {

        iPTime = aPTime;

        return KErrNone;    

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMccCodecCn::SetMaxPTime

//

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

//

TInt CMccCodecCn::SetMaxPTime( TUint aMaxPTime )

    {

    if ( aMaxPTime && ( iPTime <= aMaxPTime )&& ( KMinPtime <= aMaxPTime ) && 

        ( aMaxPTime <= KMaxPtime ) && (( aMaxPTime % KMinPtime )  == 0 ) )

        {

        iMaxPTime = aMaxPTime;

        return KErrNone;    

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMccCodecCn::SetAllowedBitrates

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

// 

TInt CMccCodecCn::SetAllowedBitrates( TUint /*aBitrateMask*/ )

    {

    return KErrNone;           

    }

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

// CMccCodecCn::CloneDefaultsL

// Make a default setting clone from this codec

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

//

CMccCodecInformation* CMccCodecCn::CloneDefaultsL()

    {

    return CMccCodecCn::NewL();

    }

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

// CMCCAMRCodec::CloneDetailedL

// Make a detailed clone from this codec

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

//

CMccCodecInformation* CMccCodecCn::CloneDetailedL()

    {

    CMccCodecCn* newCodec = CMccCodecCn::NewL();

    CleanupStack::PushL( newCodec );   

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

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

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

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

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

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

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

    newCodec->ParseFmtpAttrL( this->GetFmtpL() );

    CleanupStack::Pop( newCodec );       

    return newCodec;

    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

//  End of File