/*
* 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:    
*
*/




#include "mcedtmfcodec.h"
#include "mcecomdtmfcodec.h"

#ifdef MCE_COMMON_SERVER_SIDE

#include <mmcccodecinformation.h>
#include "mcecomaudiostream.h"
#include "mcertpsink.h"
#include "mcertpsource.h"
#include "mcemmlogs.h"

#endif //MCE_COMMON_SERVER_SIDE

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



// -----------------------------------------------------------------------------
// CMceComDtmfCodec::NewL
// -----------------------------------------------------------------------------
//
CMceComDtmfCodec* CMceComDtmfCodec::NewL( TBuf8<KMceMaxSdpNameLength> aSdpName )
    {
    CMceComDtmfCodec* self = NewLC( aSdpName );
    CleanupStack::Pop( self );
    return self;
    
    }

// -----------------------------------------------------------------------------
// CMceComDtmfCodec::NewLC
// -----------------------------------------------------------------------------
//
CMceComDtmfCodec* CMceComDtmfCodec::NewLC( TBuf8<KMceMaxSdpNameLength> aSdpName )
    {
    CMceComDtmfCodec* self = new (ELeave) CMceComDtmfCodec();
    CleanupStack::PushL( self );
    self->ConstructL( aSdpName );
    return self;
    }


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

// -----------------------------------------------------------------------------
// CMceComDtmfCodec::CMceComDtmfCodec
// -----------------------------------------------------------------------------
//
CMceComDtmfCodec::CMceComDtmfCodec()
 : CMceComAudioCodec()
    {
    iFourCC = 0;
    iEnableVAD = EFalse;
	iSamplingFreq  = KMceDtmfSamplingFreq;
	iPTime = KMceDtmfDefaultPtime;
    const TUint KMceDtmfDefaultMaxPtime = 200;
	iMaxPTime = KMceDtmfDefaultMaxPtime;
	iAllowedBitrates = KMceAllowedDtmfEvents0to15;
	iPayloadType = KMceDefaultDtmfPayloadType;
    iCodecMode = EMceOutbound;
    }


// -----------------------------------------------------------------------------
// CMceComDtmfCodec::CloneL
// -----------------------------------------------------------------------------
//
CMceComAudioCodec* CMceComDtmfCodec::CloneL()
    {
    CMceComDtmfCodec* copy = new (ELeave) CMceComDtmfCodec();
    CleanupStack::PushL( copy );
    copy->ConstructL( *this );
    CleanupStack::Pop( copy );
    return copy;
    }

// -----------------------------------------------------------------------------
// CMceComDtmfCodec::ConstructL
// -----------------------------------------------------------------------------
//
void CMceComDtmfCodec::ConstructL( TBuf8<KMceMaxSdpNameLength> aSdpName )
    {
    CMceComAudioCodec::ConstructL( aSdpName );
    }

// -----------------------------------------------------------------------------
// CMceComDtmfCodec::ConstructL
// -----------------------------------------------------------------------------
//
void CMceComDtmfCodec::ConstructL( CMceComDtmfCodec& aCodec )
    {
    CMceComAudioCodec::ConstructL( aCodec );
    }

// -----------------------------------------------------------------------------
// CMceComDtmfCodec::SetBitrate
// -----------------------------------------------------------------------------
//
TInt CMceComDtmfCodec::SetBitrate( TUint /*aBitrate*/ )
    {
	return KErrNotSupported;
    }  
   
// -----------------------------------------------------------------------------
// CMceComDtmfCodec::SetAllowedBitrates
// -----------------------------------------------------------------------------
//
TInt CMceComDtmfCodec::SetAllowedBitrates( TUint aBitrates )
    {
    // Nothing else is supported at the moment
    if( !( aBitrates == KMceAllowedDtmfEvents0to15 ) )
    	{
    	return KErrArgument;
    	}
    
    return CMceComCodec::SetAllowedBitrates( aBitrates );
    }
       
// -----------------------------------------------------------------------------
// CMceComDtmfCodec::SetCodecMode
// -----------------------------------------------------------------------------
//
TInt CMceComDtmfCodec::SetCodecMode( TUint aCodecMode )
    {
    if ( EMceOutbound == aCodecMode || EMceInbound == aCodecMode )
        {
        iCodecMode = aCodecMode;
        return KErrNone;
        }
    else
        {
        return KErrNotSupported;
        }
    }


// -----------------------------------------------------------------------------
// CMceComDtmfCodec::SetPayloadType
// -----------------------------------------------------------------------------
//
TInt CMceComDtmfCodec::SetPayloadType( TUint8 aPayloadType )
    {
    if ( KMinDynPayloadType <= aPayloadType )
        {
        return CMceComCodec::SetPayloadType( aPayloadType );
        }
    else
        {
        return KErrNotSupported;
        }
    }


// -----------------------------------------------------------------------------
// CMceComDtmfCodec::GetMaxBitRate
// -----------------------------------------------------------------------------
//
TUint CMceComDtmfCodec::GetMaxBitRate()
	{
    return 0;
    }   

// -----------------------------------------------------------------------------
// CMceComDtmfCodec::SetEnabled
// -----------------------------------------------------------------------------
//
void CMceComDtmfCodec::SetEnabled( TBool /*aIsEnabled*/ )
    {
    // Dtmf codec cannot be disabled
    }

// -----------------------------------------------------------------------------
// CMceComDtmfCodec::SendSupported
// -----------------------------------------------------------------------------
//
TBool CMceComDtmfCodec::SendSupported()
    {
    return EFalse;
    }

#ifdef MCE_COMMON_SERVER_SIDE

// -----------------------------------------------------------------------------
// CMceComDtmfCodec::DoMccValidateL
// -----------------------------------------------------------------------------
//
CMceComCodec* CMceComDtmfCodec::DoMccValidateL( CMccCodecInformation& aMccCodec,
                                                CMceSrvStream& /*aStream*/,
                                                TMceNegotiationRole /*aRole*/ )
    {
    //if answerer mcc codec represents the received offer and codec the answer
    //if offerer codec represents the sent offer and mcc codec the answer
    
    TBool notValid = ( iAllowedBitrates && aMccCodec.AllowedBitrates() == 0 );
	
	User::LeaveIfError( notValid ? KErrNotSupported : KErrNone );
	
	return NULL;
    }

// -----------------------------------------------------------------------------
// CMceComDtmfCodec::DoDecodeAudioL
// -----------------------------------------------------------------------------
//

void CMceComDtmfCodec::DoDecodeAudioL( 
    TInt aCodecIndex,
    RPointerArray<CMceSrvStream>& aStreams,
    CMceComAudioStream& aAudio,
    CMceMediaManager& aManager )
    {
    // Special handling for dtmf codecs, need to create dummy source
    // for dtmf uplink and dummy sink for dtmf downlink
    //
    if ( IS_RECEIVESTREAM( &aAudio ) )
        {
        if ( aAudio.Source()->Type() == KMceRTPSource )
            {
            CMceComMediaSink& emptySink = aAudio.EmptySinkL();
            CMceSrvStream* srvStream = 
                CMceSrvStream::NewL( aManager, 
                                     aAudio, 
                                     *aAudio.Source(),
                                     emptySink,
                                     *this );
            CleanupStack::PushL( srvStream );
            MCEMM_DEBUG_STREAM( "CMceComDtmfCodec::DoDecodeAudioL(): decoded dtmf downlink", 
                                *srvStream );
            aStreams.AppendL( srvStream );
            CleanupStack::Pop( srvStream );
            }
        }
    else
        {
        CMceComMediaSink* rtpSink = NULL;
        for( TInt sinkNdx = 0; sinkNdx < aAudio.Sinks().Count() && !rtpSink; sinkNdx++ )
            {
            if ( aAudio.Sinks()[ sinkNdx ]->Type() == KMceRTPSink )
                {
                rtpSink = aAudio.Sinks()[ sinkNdx ];
                }
            }   
        if ( rtpSink )
            {
            CMceComMediaSource& emptySource = aAudio.EmptySourceL();
            CMceSrvStream* srvStream = 
                CMceSrvStream::NewL( aManager, 
                                     aAudio, 
                                     emptySource,
                                     *rtpSink,
                                     *this );
            CleanupStack::PushL( srvStream );
            MCEMM_DEBUG_STREAM( "CMceComDtmfCodec::DoDecodeAudioL(): decoded dtmf uplink", 
                                *srvStream );
            aStreams.AppendL( srvStream );
            CleanupStack::Pop( srvStream );
            }
        }
    
    // As dtmf cannot be used for streaming, select some other codec
    // for sending.    

    const TInt codecCount = aAudio.CodecCount();

    for ( TInt i = 0 ; i < codecCount ; ++i )
        {
        UpdateSendCodec( aCodecIndex, aAudio, *aAudio.CodecL( i ) );
        }
    }
    
#endif
    
// End of File