/*
* 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:    Factory class to create Codec information instances
*
*/





// INCLUDE FILES
#include "mmcccodecmsrp.h"
#include "mccuids.hrh"
#include "mmccinterfacelogs.h"


// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// -----------------------------------------------------------------------------
// CMccCodecMsrp::CMccCodecMsrp
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CMccCodecMsrp::CMccCodecMsrp() : CMccCodecInformation()
    {
    }

// -----------------------------------------------------------------------------
// CMccCodecMsrp::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CMccCodecMsrp::ConstructL()
    {
    iSdpName.Copy( KMSRPSdpName );
	iType = KUidMediaTypeMessage;

    iHwFrameTime = 20;
    iFrameSize = 20;
    SetSamplingFreq( 1000 );
    SetBitrate( 64 );
    EnableVAD( EFalse );
    SetMaxPTime( 100 );
    SetPTime( 20 );
    iFourCC = KMccFourCCIdMSRP;
    iPayloadFormatEncoder = KImplUidMsrpPayloadFormatEncode;
    iPayloadFormatDecoder = KImplUidMsrpPayloadFormatDecode;
    }

// -----------------------------------------------------------------------------
// CMccCodecMsrp::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CMccCodecMsrp* CMccCodecMsrp::NewL()
    {
    CMccCodecMsrp* self = new( ELeave ) CMccCodecMsrp;
    
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );

    return self;
    }

// -----------------------------------------------------------------------------
// CMccCodecMsrp::~CMccCodecMsrp
// 
// -----------------------------------------------------------------------------
//
CMccCodecMsrp::~CMccCodecMsrp()
    {
    }

// -----------------------------------------------------------------------------
// CMccCodecMsrp::RequireSignalling
// -----------------------------------------------------------------------------
//
TBool CMccCodecMsrp::RequireSignalling(
    const CMccCodecInformation& aCandidate ) const      
    {
    __INTERFACE( "CMccCodecMsrp::RequireSignalling" )
    TBool ret = EFalse;
              
    if ( iPTime != aCandidate.PTime() )
        {
        __INTERFACE( "CMccCodecMsrp::RequireSignalling, PTime changed" )
        ret = ETrue;
        }
        
    if ( iMaxPTime != aCandidate.MaxPTime() )
        {
        __INTERFACE( "CMccCodecMsrp::RequireSignalling, MaxPTime changed" )
        ret = ETrue;
        }
        
    if ( iPayloadType != aCandidate.PayloadType() )
        {
        __INTERFACE( "CMccCodecMsrp::RequireSignalling, PayloadType changed" )
        ret = ETrue;
        }

    if ( iBitrateMask != aCandidate.AllowedBitrates() )
        {
        __INTERFACE( "CMccCodecMsrp::RequireSignalling, BitrateMask changed" )
        ret = ETrue;
        }

    if ( iCodecMode != aCandidate.CodecMode() )
        {
        __INTERFACE( "CMccCodecMsrp::RequireSignalling, CodecMode changed" )
        ret = ETrue;
        }
        
    if ( iSamplingFreq != aCandidate.SamplingFreq() )
        {
        __INTERFACE( "CMccCodecMsrp::RequireSignalling, SamplingFreq changed" )
        ret = ETrue;
        }     
        
    if ( iMaxBitrate != aCandidate.MaxBitrate() )
        {
        __INTERFACE( "CMccCodecMsrp::RequireSignalling, MaxBitrate changed" )
        ret = ETrue;
        }
             
    __INTERFACE_INT1( "CMccCodecMsrp::RequireSignalling, exit with", ret )
    return ret;          
    }
 
// -----------------------------------------------------------------------------
// CMccCodecMsrp::SetBitrate
// Sets the bitrate used with AMR codec.
// -----------------------------------------------------------------------------
//
TInt CMccCodecMsrp::SetBitrate( TUint aBitrate )
    {
    
    // Not supported
    iBitrate = aBitrate;
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CMccCodecMsrp::SetSamplingFreq
// Sets the sampling frequency. 
// -----------------------------------------------------------------------------
//
TInt CMccCodecMsrp::SetSamplingFreq( TUint32 aSamplingFreq )
    {
    // Not supported
    
    iSamplingFreq = aSamplingFreq;
    return KErrNone;
    }
    
// -----------------------------------------------------------------------------
// CMccCodecMsrp::SetSdpName
// Sets the SDP name
// -----------------------------------------------------------------------------
//
TInt CMccCodecMsrp::SetSdpName( const TDesC8& aSdpName )
    {
    // Not supported
    iSdpName.Copy( aSdpName );
    
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CMccCodecMsrp::PayloadType
// Sets the payload type
// -----------------------------------------------------------------------------
//
TInt CMccCodecMsrp::SetPayloadType( TUint8 /*aPayloadType*/ )
    {
    // Not supported
    TUint8 aPayloadType = KPayloadType; // dummy value for messgae codec payload type aPayloadType;
    iPayloadType = aPayloadType;
    
    return KErrNone;
    }
    
// -----------------------------------------------------------------------------
// CMccCodecMsrp::SetCodecMode
// Sets the codec mode.
// -----------------------------------------------------------------------------
//
TInt CMccCodecMsrp::SetCodecMode( TCodecMode aCodecMode )
    {
    // Not supported
    iCodecMode = aCodecMode;
    return KErrNone;
    }
 
// -----------------------------------------------------------------------------
// CMccCodecMsrp::EnableVAD
// Enable / Disable VAD
// -----------------------------------------------------------------------------
//
TInt CMccCodecMsrp::EnableVAD( TBool /*aEnableVAD*/ ) 
    {
    // Not supported
    return KErrNone;
    }
    
// -----------------------------------------------------------------------------
// CMccCodecMsrp::SetPTime
// Set PTime
// -----------------------------------------------------------------------------
//
TInt CMccCodecMsrp::SetPTime( TUint /*aPTime*/ )
    {
    // Not supported
    return KErrNone;
    }
    
// -----------------------------------------------------------------------------
// CMccCodecMsrp::SetMaxPTime
// Set Max PTime
// -----------------------------------------------------------------------------
//
TInt CMccCodecMsrp::SetMaxPTime( TUint /*aMaxPTime*/ )
    {
    // Not supported
    return KErrNone;
    }
    
// -----------------------------------------------------------------------------
// CMccCodecMsrp::CloneDefaultsL
// Make a default setting clone from this codec
// -----------------------------------------------------------------------------
//
CMccCodecInformation* CMccCodecMsrp::CloneDefaultsL()
    {
    return CMccCodecMsrp::NewL();
    }

// -----------------------------------------------------------------------------
// CMccCodecMsrp::CloneDetailedL
// Make a detailed clone from this codec
// -----------------------------------------------------------------------------
//
CMccCodecInformation* CMccCodecMsrp::CloneDetailedL()
    {
    CMccCodecMsrp* newCodec = CMccCodecMsrp::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() );
    CleanupStack::Pop( newCodec );   
    return newCodec;
    }
        
// ========================== OTHER EXPORTED FUNCTIONS =========================

//  End of File