/*
* Copyright (c) 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:    
*
*/





// INCLUDE FILES
#include "mmcccodecaac.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 ===============================

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

// -----------------------------------------------------------------------------
// CMccCodecAAC::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CMccCodecAAC::ConstructL()
    {
    iSdpName.Copy( KAACSdpName );

    iType = KUidMediaTypeAudio;
    }

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

    return self;
    }

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

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

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

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

// -----------------------------------------------------------------------------
// CMccCodecAAC::SetSamplingFreq
// Sets the sampling frequency. 
// -----------------------------------------------------------------------------
//
TInt CMccCodecAAC::SetSamplingFreq( TUint32 aSamplingFreq )
    {
    iSamplingFreq = aSamplingFreq;
    return KErrNone;
    }
    
// -----------------------------------------------------------------------------
// CMccCodecAAC::SetSdpName
// Sets the SDP name
// -----------------------------------------------------------------------------
//
TInt CMccCodecAAC::SetSdpName( const TDesC8& aSdpName )
    {
    if ( 0 == aSdpName.CompareF( KAACSdpName ) )
        {
        iSdpName.Copy( aSdpName );
        }
    else 
        {
        return KErrNotSupported;
        }
    
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CMccCodecAAC::PayloadType
// Sets the payload type
// -----------------------------------------------------------------------------
//
TInt CMccCodecAAC::SetPayloadType( TUint8 aPayloadType )
    {
    if ( aPayloadType < KMinDynamicPT ||
         aPayloadType > KMaxPayloadType ) 
        {
        return KErrNotSupported;
        }
    else 
        {
        iPayloadType = aPayloadType;
        }
              
    return KErrNone;
    }
    
// -----------------------------------------------------------------------------
// CMccCodecAAC::SetCodecMode
// Sets the codec mode.
// -----------------------------------------------------------------------------
//
TInt CMccCodecAAC::SetCodecMode( TCodecMode aCodecMode )
    {
    iCodecMode = aCodecMode;
    return KErrNone;
    }
 
// -----------------------------------------------------------------------------
// CMccCodecAAC::EnableVAD
// Enable / Disable VAD
// -----------------------------------------------------------------------------
//
TInt CMccCodecAAC::EnableVAD( TBool /*aEnableVAD*/ ) 
    {
    return KErrNotSupported;
    }
    
// -----------------------------------------------------------------------------
// CMccCodecAAC::SetPTime
// Set PTime
// -----------------------------------------------------------------------------
//
TInt CMccCodecAAC::SetPTime( TUint /*aPTime*/ )
    {
    return KErrNotSupported;
    }
    
// -----------------------------------------------------------------------------
// CMccCodecAAC::SetMaxPTime
// Set Max PTime
// -----------------------------------------------------------------------------
//
TInt CMccCodecAAC::SetMaxPTime( TUint /*aMaxPTime*/ )
    {
    return KErrNotSupported;
    }
    
// -----------------------------------------------------------------------------
// CMccCodecAAC::CloneDefaultsL
// Make a default setting clone from this codec
// -----------------------------------------------------------------------------
//
CMccCodecInformation* CMccCodecAAC::CloneDefaultsL()
    {
    return CMccCodecAAC::NewL();
    }

// -----------------------------------------------------------------------------
// CMccCodecAAC::CloneDetailedL
// Make a detailed clone from this codec
// -----------------------------------------------------------------------------
//
CMccCodecInformation* CMccCodecAAC::CloneDetailedL()
    {
    CMccCodecAAC* newCodec = CMccCodecAAC::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  
