/*

* Copyright (c) 2004-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:    MCC G.729 CodecInformation

*

*/

// INCLUDE FILES

#include "mmcccodecg729.h"

#include "mmccinterfacelogs.h"

#include "mccuids.hrh"

// CONSTANTS

const TInt KG729DefaultHwFrameTime( 10 );

// LOCAL CONSTANTS AND MACROS

const TUint8 KG729KAPayloadSize = 10;

const TUint8 KG729KeepAlivePayload[KG729KAPayloadSize] = 

    { 

    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

    };

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

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

// CMCCCodecG729::CMCCCodecG729

// default constructor

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

//

CMCCCodecG729::CMCCCodecG729() : CMccCodecInformation()

    {

    }

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

// CMCCCodecG729::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMCCCodecG729::ConstructL()

    {

    __INTERFACE( "CMCCCodecG729::ConstructL" )

    SetSdpName( KG729SdpName );

    iKeepAliveData.Copy( KG729KeepAlivePayload );   

    // setting some default values 

    SetSamplingFreq( KG729SampleRate );

    SetBitrate( KG729Bitrate );

    EnableVAD( EFalse );

    iHwFrameTime = KG729DefaultHwFrameTime; // default 20ms    

    SetMaxPTime( KMaxPtime );

    SetPTime( KDefaultPtime );

    SetPayloadType( KG729PayloadType );

    iCodecMode = ENothing;

    iFourCC = KMccFourCCIdG729;

    iPayloadFormatEncoder = KImplUidG729PayloadFormatEncode;

    iPayloadFormatDecoder = KImplUidG729PayloadFormatDecode;

    }

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

// CMCCCodecG729::NewL

// Static constructor.

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

//

CMCCCodecG729* CMCCCodecG729::NewL()

    {

    CMCCCodecG729* self = new (ELeave) CMCCCodecG729;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); 

    return self;

    }

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

// CMCCCodecG729::~CMCCCodecG729

// Destructor

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

//

CMCCCodecG729::~CMCCCodecG729()

    {

    __INTERFACE( "CMCCCodecG729::~CMCCCodecG729" )

    }

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

// CMCCCodecG729::EnableVAD

// Enable / Disable VAD

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

//

TInt CMCCCodecG729::EnableVAD( TBool aEnableVAD )

    {

    iEnableVAD = aEnableVAD;

    return KErrNone;

    }

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

// CMCCCodecG729::SetBitrate

// Set Bitrate

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

//

TInt CMCCCodecG729::SetBitrate( TUint aBitrate )

    {

    if( KG729Bitrate != aBitrate )

        {

        return KErrNotSupported;

        }

    else

        {

        iBitrate = aBitrate;

        return KErrNone;

        }

    }

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

// CMCCCodecG729::SetSamplingFreq

// Set Sampling Frequency 

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

//    

TInt CMCCCodecG729::SetSamplingFreq( TUint32 aSamplingFreq )

    {

    if ( KG729SampleRate == aSamplingFreq )

        {

        iSamplingFreq = aSamplingFreq;

        return KErrNone;

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMCCCodecG729::SetSdpName

// Set SDP Name

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

//

TInt CMCCCodecG729::SetSdpName( const TDesC8& aSdpName )

    {

    if ( !aSdpName.CompareF( KG729SdpName ) )

        {

        iSdpName.Copy( aSdpName );

        }

    else 

        {

        return KErrNotSupported;        

        }

    return KErrNone;

    }

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

// CMCCCodecG729::SetPayloadType

// Set PayloadType 

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

//

TInt CMCCCodecG729::SetPayloadType( TUint8 aPayloadType )

    {

    if ( KG729PayloadType != aPayloadType ) 

        {

        return KErrNotSupported;

        }

    else 

        {

        iPayloadType = aPayloadType;

        return KErrNone;

        }

    }

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

// CMCCCodecG729::SetPTime

// Set PacketTime

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

//

TInt CMCCCodecG729::SetPTime( TUint aPTime )

    {

    __INTERFACE_INT2( "CMCCCodecG729::SetPTime [aPTime, iPTime]",

        aPTime, iPTime )

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

         ( aPTime <= KMaxPtime ) && 

         ( aPTime <= iMaxPTime ) && 

         !( aPTime % KMinPtime ) )

        {

        iPTime = aPTime;

        return KErrNone;

        }

    else

        {

        return KErrArgument;

        }

    }

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

// CMCCCodecG729::SetMaxPTime

// Set Maximum PacketTime

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

//

TInt CMCCCodecG729::SetMaxPTime( TUint aMaxPTime )

    {

    __INTERFACE_INT2( "CMCCCodecG729::SetMaxPTime [aMaxPTime, iMaxPTime]",

        aMaxPTime, iMaxPTime )

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

         ( KMinPtime <= aMaxPTime ) && 

         ( aMaxPTime <= KMaxPtime ) && 

         !( aMaxPTime % KMinPtime ) )

        {

        iMaxPTime = aMaxPTime;

        return KErrNone;

        }

    else

        {

        return KErrArgument;

        }

    }

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

// CMCCCodecG729::SetCodecMode

// Set Codec Mode

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

//   

TInt CMCCCodecG729::SetCodecMode( TCodecMode aCodecMode )

    {

    if ( ENothing == aCodecMode )

        {

        iCodecMode = aCodecMode;

        return KErrNone;

        }

    else

        {

        return KErrNotSupported;

        }

    }

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

// CMCCCodecG729::CloneDefaultsL

// Make a default setting clone from this G.729 codec

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

//

CMccCodecInformation* CMCCCodecG729::CloneDefaultsL()

    {

    return CMCCCodecG729::NewL();

    };

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

// CMCCCodecG729::CloneDetailedL

// Make a detailed clone from this G.729 codec

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

//

CMccCodecInformation* CMCCCodecG729::CloneDetailedL()

    {

    CMCCCodecG729* newCodec = CMCCCodecG729::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;

    };

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

// CMCCCodecG729::RequireSignalling

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

//

TBool CMCCCodecG729::RequireSignalling(

    const CMccCodecInformation& aCandidate ) const      

    {

    __INTERFACE( "CMCCCodecG729::RequireSignalling" )

    TBool ret = EFalse;

    if ( iPTime != aCandidate.PTime() )

        {

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

        ret = ETrue;

        }

    if ( iMaxPTime != aCandidate.MaxPTime() )

        {

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

        ret = ETrue;

        }

    if ( iPayloadType != aCandidate.PayloadType() )

        {

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

        ret = ETrue;

        }

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

    return ret;          

    }

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

// CMCCCodecG729::CreateFmtpAttrListL

// Builds fmtp line according to current parameters.

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

//

void CMCCCodecG729::CreateFmtpAttrListL()

    {

    HBufC8* buf = HBufC8::NewLC( KMaxFmtpLen ); 

    TPtr8 bufPtr = buf->Des();

    if ( iEnableVAD )

        {

        bufPtr.Append( KAnnexYes );

        }

    else

        {

        bufPtr.Append( KAnnexNo );

        }

    // Update iFmtpAttr

    SetFmtpAttrL( bufPtr, EFalse );

    CleanupStack::PopAndDestroy( buf );

    }

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

// CMccCodecInformation::ParseFmtpAttrL

// Parse the fmtp string, but doesn't update the iFmtpAttr

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

//

TBool CMCCCodecG729::ParseFmtpAttrL( const TDesC8& aFmtp )

    {

    TBool updated( EFalse );

    if ( !aFmtp.CompareF( KAnnexYes ) )

        {

        iEnableVAD = ETrue;

        updated = ETrue;

        }

    else if ( !aFmtp.CompareF( KAnnexNo ) || !aFmtp.Length() )

        {

        iEnableVAD = EFalse;

        updated = ETrue;

        }

    else

        {

        User::Leave( KErrArgument );

        }

    return updated;

    }

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

// CMCCCodecG729::GetFmtpL

// Gets the fmtp attribute

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

//

TDesC8& CMCCCodecG729::GetFmtpL()

    {

    __INTERFACE( "CMCCCodecG729::GetFmtpL" )      

    if ( iFmtpAttr )

        {

        delete iFmtpAttr;

        iFmtpAttr = NULL;

        }

    CreateFmtpAttrListL();    

    __INTERFACE( "CMccCodecG729::GetFmtpL, exit" )      

    return *iFmtpAttr;    

    }

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

// CMCCCodecG729::SetAllowedBitrates

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

// 

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

    {

    return KErrNone;           

    }

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

//  End of File