/*

* Copyright (c) 2004-2008 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:    Codec configurator for Mcc subthreads

*

*/

// INCLUDE FILES

#include <mmf/server/mmfaudioinput.h>

#include <mmf/server/mmfaudiooutput.h>

#include <mmf/server/mmfformat.h>

#include <e32math.h>

#include <3gplibrary/mp4lib.h>

#include <SpeechEncoderConfig.h>

#include <ErrorConcealmentIntfc.h>

#include <G729DecoderIntfc.h>

#include <G729EncoderIntfc.h>

#include <G711DecoderIntfc.h>

#include <G711EncoderIntfc.h>

#include <IlbcDecoderIntfc.h>

#include <IlbcEncoderIntfc.h>

#include "mcccodecconfigurator.h"

#include "mccinternalcodecs.h"

#include "mmcccodecinformation.h"

#include "mmccinterfacedef.h"

#include "mccinternaldef.h"

#include "formatstatemachine.h"

#include "mccvideosource.h"

#include "mccvideosink.h"

#include "mccfilesink.h"

#include "mccsubcontrollerlogs.h"

#include "dtmfpayloadformatwrite.h"

#include "dtmfpayloadformatread.h"

// LOCAL CONSTANTS

// AMR-NB Codec possible bitrates

const TInt KAmrNbBitrate475 = 4750;

const TInt KAmrNbBitrate515 = 5150;

const TInt KAmrNbBitrate590 = 5900;

const TInt KAmrNbBitrate670 = 6700;

const TInt KAmrNbBitrate740 = 7400;

const TInt KAmrNbBitrate795 = 7950;

const TInt KAmrNbBitrate102 = 10200;

const TInt KAmrNbBitrate122 = 12200;

// AMR-WB Codec possible bitrates

const TInt KAmrWbBitrate660 = 6600;

const TInt KAmrWbBitrate885 = 8850;

const TInt KAmrWbBitrate1265 = 12650;

const TInt KAmrWbBitrate1425 = 14250;

const TInt KAmrWbBitrate1585 = 15850;

const TInt KAmrWbBitrate1825 = 18250;

const TInt KAmrWbBitrate1985 = 19850;

const TInt KAmrWbBitrate2305 = 23050;

const TInt KAmrWbBitrate2385 = 23850;

// iLBC Codec possible bitrates

const TInt KIlbcBitrate1520 = 15200;

const TInt KIlbcBitrate1333 = 13330;

// G.711 Modes

const TInt KG711ModeaLaw = 3;

const TInt KG711ModeuLaw = 2;

// MACROS

#define MCC_CODEC_CONF_SET_VAD_L( curr_vad, get_func, new_vad, set_func ) \

__SUBCONTROLLER( "MccCodecConfigurator:: setting vad" ) \

TBool curr_vad( EFalse ); \

TInt get_vad_err = get_func; \

__SUBCONTROLLER_INT1( "MccCodecConfigurator:: get vad err:", get_vad_err ) \

__SUBCONTROLLER_INT1( "MccCodecConfigurator:: curr vad:", curr_vad ) \

if ( !get_vad_err && curr_vad != new_vad ) \

    { \

    TRAP_IGNORE(User::LeaveIfError( set_func )); \

    __SUBCONTROLLER_INT1( "MccCodecConfigurator:: vad set to:", new_vad ) \

    }

#if ( defined __WINSCW__ ) || ( defined __WINS__ ) || ( defined TEST_EUNIT )

#define MCC_CODEC_CONF_DISABLE_CONFIGURATION

#endif   

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

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

// MccCodecConfigurator::ConfigureCodecL

// Generic codec configuration for codecs

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

void MccCodecConfigurator::ConfigureCodecL( 

    MDataSource& aDatasource, 

    MDataSink& aDatasink, 

    const TMccCodecInfo& aCodec,

    CMccRtpMediaClock& aClock,

    CMccSymStreamBase::TCodecState aCodecState,

    MDataSink* aAssociatedDatasink )

    {

	__SUBCONTROLLER( "MccCodecConfigurator::ConfigureCodecL" )

	__SUBCONTROLLER( "MccCodecConfigurator::ConfigureCodecL, checking codec" )

    User::LeaveIfError( TMccCodecInfo::CheckCodecInfo( aCodec ) );

    if( KUidMmfAudioInput == aDatasource.DataSourceType() )

        {        

		__SUBCONTROLLER( "MccCodecConfigurator::ConfigureCodecL, KUidMmfAudioInput" )

        MMMFAudioInput& record_device = static_cast<MMMFAudioInput&>( aDatasource );

        CPayloadFormatWrite& format_enc = static_cast<CPayloadFormatWrite&>( aDatasink );

        DoConfigureLiveAudioUplinkStreamL( record_device, format_enc, aCodec, aClock, aCodecState );

        }

    else if( KUidMmfAudioOutput == aDatasink.DataSinkType() )

        {

		__SUBCONTROLLER( "MccCodecConfigurator::ConfigureCodecL, KUidMmfAudioOutput" )

        MMMFAudioOutput& play_device = static_cast<MMMFAudioOutput&>( aDatasink );

        CPayloadFormatRead& format_dec = static_cast<CPayloadFormatRead&>( aDatasource );

        DoConfigureLiveAudioDownlinkStreamL( play_device, format_dec, aCodec, aCodecState );

        }

    else if( KMccFileSourceUid == aDatasource.DataSourceType() )

        {

        __SUBCONTROLLER( "MccCodecConfigurator::ConfigureCodecL, KMccFileSourceUID" )

        if ( KMccFileSinkUid != aDatasink.DataSinkType() )

            {

    	    CPayloadFormatWrite& format = static_cast<CPayloadFormatWrite&>( aDatasink );

    	    DoConfigureClipUplinkStreamL( format, aCodec, aAssociatedDatasink, aClock );

	        PassPrerollFromSinkToSourceL(aAssociatedDatasink, &aDatasource);

            }

        }

    else if ( KMccFileSinkUid == aDatasink.DataSinkType() )

	    {

        if ( KMccVideoSourceUid == aDatasource.DataSourceType() )

            {

            __SUBCONTROLLER( "MccCodecConfigurator::ConfigureCodecL, KMccFileSinkUID, KMccVideoSourceUid" )

            DoConfigureCameraL( static_cast<CMccVideoSource&>( aDatasource ), aCodec );

            DoConfigureFileSinkL( static_cast<CMccFileSink&>( aDatasink ), aCodec );

            }

        else

            {

            __SUBCONTROLLER( "MccCodecConfigurator::ConfigureCodecL, KMccFileSinkUID, source decoder" )

            CPayloadFormatRead& formatDec = static_cast<CPayloadFormatRead&>( aDatasource );

		    TMccCodecInfoBuffer buffer( aCodec );

            formatDec.ConfigurePayloadFormatL( buffer );

            }

	    }

    else if( KMccVideoSourceUid == aDatasource.DataSourceType() )

        {

	    CPayloadFormatWrite& format = static_cast<CPayloadFormatWrite&>( aDatasink );

		__SUBCONTROLLER( "CMccCodecConfigurator::ConfigureCodecL, KMccVideoSourceUID, video" )

	    CMccVideoSource& recordDevice = static_cast<CMccVideoSource&>( aDatasource );

	    DoConfigureLiveVideoUplinkStreamL( recordDevice, format, aCodec, aAssociatedDatasink, aClock  );

        }

    else if( KMccVideoSinkUid == aDatasink.DataSinkType() )

        {

		__SUBCONTROLLER( "MccCodecConfigurator::ConfigureCodecL, KMccVideoSinkUID" )

		if ( KUidMmfFormatDecode == aDatasource.DataSourceType() )

		    {

		    __SUBCONTROLLER( "MccCodecConfigurator::ConfigureCodecL, source decoder" )

	        CPayloadFormatRead& formatDec = static_cast<CPayloadFormatRead&>( aDatasource );

            DoConfigureLiveVideoDownlinkStreamL( &aDatasink, formatDec, aCodec );

		    }

        }        

    else if ( aCodec.iFourCC == KMccFourCCIdDTMF )

        {

        __SUBCONTROLLER( "MccCodecConfigurator::ConfigureCodecL, KMccFourCCIdDTMF" )

        if ( KUidMmfFormatDecode == aDatasource.DataSourceType() )

            {

            CPayloadFormatRead& formatDec = static_cast<CPayloadFormatRead&>( aDatasource );

            DoConfigureDtmfFormatL( formatDec, aCodec );

            }

        else if ( KUidMmfFormatEncode == aDatasink.DataSinkType() )

            {

            CPayloadFormatWrite& formatEnc = static_cast<CPayloadFormatWrite&>( aDatasink );

            DoConfigureDtmfFormatL( formatEnc, aCodec, aClock );

            }

        else

            {

            User::Leave( KErrArgument );

            }

        }

    else

        {

		__SUBCONTROLLER( "MccCodecConfigurator::ConfigureCodecL, KErrArgument" )

        User::Leave( KErrArgument );

        }

	__SUBCONTROLLER( "MccCodecConfigurator::ConfigureCodecL, exit" )

    }

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

// MccCodecConfigurator::DoConfigureAmrL

// Configures the AMR record device

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

void MccCodecConfigurator::DoConfigureAmrL( 

    MMMFAudioOutput& aPlaybackDev, 

    const TMccCodecInfo& aCodec )

    {

	__SUBCONTROLLER( "MccCodecConfigurator::DoConfigureAmrL, decoder" )

    TFourCC fourcc( aCodec.iFourCC );

    const TUint32 fourccVal = fourcc.FourCC();

    if ( ( fourccVal == KMccFourCCIdAMRNB && 

           !IsSupportedAmrNbBitrate( aCodec.iBitrate ) ) ||

         ( fourccVal == KMccFourCCIdAMRWB && 

           !IsSupportedAmrWbBitrate( aCodec.iBitrate ) ) )

        {

        User::Leave( KErrNotSupported );

        }

    __SUBCONTROLLER( "MccCodecConfigurator, bitrate allowed" )

    CErrorConcealmentIntfc* errorConcealIf = 

        CErrorConcealmentIntfc::NewL( aPlaybackDev.SoundDevice() );

    errorConcealIf->SetFrameMode( ETrue );

    delete errorConcealIf;

    errorConcealIf = NULL;

	__SUBCONTROLLER( "MccCodecConfigurator::DoConfigureAmrL, exit" )

    }

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

// MccCodecConfigurator::DoConfigureAmrL

// Configures the AMR playback device

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

void MccCodecConfigurator::DoConfigureAmrL( 

    MMMFAudioInput& aRecordDev, 

    const TMccCodecInfo& aCodec )

    {

	__SUBCONTROLLER( "MccCodecConfigurator::DoConfigureAmrL, encoder" )

    TFourCC fourcc( aCodec.iFourCC );

    const TUint32 fourccVal = fourcc.FourCC();

    if ( ( fourccVal == KMccFourCCIdAMRNB && 

           !IsSupportedAmrNbBitrate( aCodec.iBitrate ) ) ||

         ( fourccVal == KMccFourCCIdAMRWB && 

           !IsSupportedAmrWbBitrate( aCodec.iBitrate ) ) )

        {

        User::Leave( KErrNotSupported );

        }

    __SUBCONTROLLER( "MccCodecConfigurator, bitrate allowed" )

    CSpeechEncoderConfig* speechEncConfIf = 

            CSpeechEncoderConfig::NewL( aRecordDev.SoundDevice() );

    CleanupStack::PushL( speechEncConfIf );

	__SUBCONTROLLER( "MccCodecConfigurator, setting VAD" )

    TBool requestedEnableVad = aCodec.iEnableDTX;

	MCC_CODEC_CONF_SET_VAD_L( currentVad,

	                          speechEncConfIf->GetVadMode( currentVad ),

	                          requestedEnableVad, 

                        	  speechEncConfIf->SetVadMode( requestedEnableVad ) )

    __SUBCONTROLLER_INT1( "MccCodecConfigurator, setting bitrate", aCodec.iBitrate )

    TUint bitrate( 0 );

    User::LeaveIfError( speechEncConfIf->GetBitrate( bitrate ) );

    if ( bitrate != aCodec.iBitrate )

        {

        User::LeaveIfError( speechEncConfIf->SetBitrate( aCodec.iBitrate ) );

        }

    CleanupStack::PopAndDestroy( speechEncConfIf );

	__SUBCONTROLLER( "MccCodecConfigurator::DoConfigureAmrL, exit" )

    }

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

// MccCodecConfigurator::DoConfigureG711L

// Configures the G.711 playback device

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

//

void MccCodecConfigurator::DoConfigureG711L( 

    MMMFAudioOutput& aPlaybackDev, 

    const TMccCodecInfo& aCodec,

    CMccSymStreamBase::TCodecState aCodecState )

    {

	__SUBCONTROLLER( "MccCodecConfigurator::DoConfigureG711L, decoder" )

    CG711DecoderIntfc* g711DecIf = 

            CG711DecoderIntfc::NewL( aPlaybackDev.SoundDevice() );

    CleanupStack::PushL( g711DecIf );

    // Cannot change mode on fly, 

    // changing it only right after the codec has been loaded

    if ( aCodecState == CMccSymStreamBase::EStateCodecLoaded )

        {

        if( KG711ModeaLaw == aCodec.iCodecMode )

            {

            __SUBCONTROLLER( "MccCodecConfigurator::DoConfigureG711L, aLaw" )

            User::LeaveIfError( g711DecIf->SetDecoderMode(

                CG711DecoderIntfc::EDecALaw ) );

            }

        else if( KG711ModeuLaw == aCodec.iCodecMode )

            {

            __SUBCONTROLLER( "MccCodecConfigurator::DoConfigureG711L, uLaw" )

            User::LeaveIfError( g711DecIf->SetDecoderMode(

                CG711DecoderIntfc::EDecULaw ) );  

            }

        else

            {

            User::Leave( KErrNotSupported );

            }

        }

    TBool enableCng = ConvertBoolean( aCodec.iEnableDTX );

    MCC_CODEC_CONF_SET_VAD_L( currentVad,

	                          g711DecIf->GetCng( currentVad ),

	                          enableCng, 

                        	  g711DecIf->SetCng( enableCng ) )

    CleanupStack::PopAndDestroy( g711DecIf );

    }

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

// MccCodecConfigurator::DoConfigureG711L

// Configures the G.711 record device

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

//

void MccCodecConfigurator::DoConfigureG711L( 

    MMMFAudioInput& aRecordDev, 

    const TMccCodecInfo& aCodec,

    CMccSymStreamBase::TCodecState aCodecState )

    {

	__SUBCONTROLLER( "MccCodecConfigurator::DoConfigureG711L, encoder" )

    CG711EncoderIntfc* g711EncIf = 

            CG711EncoderIntfc::NewL( aRecordDev.SoundDevice() );

    CleanupStack::PushL( g711EncIf );

    // Cannot change mode on fly, 

    // changing it only right after the codec has been loaded

    if ( aCodecState == CMccSymStreamBase::EStateCodecLoaded )

        {

        if( KG711ModeaLaw == aCodec.iCodecMode )

            {

            __SUBCONTROLLER( "MccCodecConfigurator::DoConfigureG711L, aLaw" )

            User::LeaveIfError( g711EncIf->SetEncoderMode(

                CG711EncoderIntfc::EEncALaw ) );

            }

        else if ( KG711ModeuLaw == aCodec.iCodecMode )

            {

            __SUBCONTROLLER( "MccCodecConfigurator::DoConfigureG711L, uLaw" )

            User::LeaveIfError( g711EncIf->SetEncoderMode(

                CG711EncoderIntfc::EEncULaw ) );

            }

        else

            {

            User::Leave( KErrNotSupported );

            }

        }

    TBool enableVad = ConvertBoolean( aCodec.iEnableDTX );

	MCC_CODEC_CONF_SET_VAD_L( currentVad,

	                          g711EncIf->GetVadMode( currentVad ),

	                          enableVad, 

                        	  g711EncIf->SetVadMode( enableVad ) )                      	  

    CleanupStack::PopAndDestroy( g711EncIf );

    }

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

// MccCodecConfigurator::DoConfigureG729L

// Configures the G.729 playback device

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

//

void MccCodecConfigurator::DoConfigureG729( MMMFAudioOutput& /*aPlaybackDev*/ )

    {

	__SUBCONTROLLER( "MccCodecConfigurator::DoConfigureG729, decoder, NOP" )

    }

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

// MccCodecConfigurator::DoConfigureG729L

// Configures the G.729 record device

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

//

void MccCodecConfigurator::DoConfigureG729L( MMMFAudioInput& aRecordDev,

    TBool aEnableCng )

    {

    __SUBCONTROLLER( "MccCodecConfigurator::DoConfigureG729, encoder" )

    CG729EncoderIntfc* encG729If = 

            CG729EncoderIntfc::NewL( aRecordDev.SoundDevice() );

    CleanupStack::PushL( encG729If );

    TBool enableVad = ConvertBoolean( aEnableCng );

   	MCC_CODEC_CONF_SET_VAD_L( currentVad,

	                          encG729If->GetVadMode( currentVad ),

	                          enableVad, 

                        	  encG729If->SetVadMode( enableVad ) )     

    CleanupStack::PopAndDestroy( encG729If );       

    }

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

// MccCodecConfigurator::DoConfigureIlbcL

// Configures the iLBC playback device

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

//

void MccCodecConfigurator::DoConfigureIlbcL( 

    MMMFAudioOutput& aPlaybackDev, 

    const TMccCodecInfo& aCodec,

    CMccSymStreamBase::TCodecState aCodecState )

    {

    __SUBCONTROLLER( "MccCodecConfigurator::DoConfigureIlbcL decoder" )

    __SUBCONTROLLER_INT1( "MccCodecConfigurator::DoConfigureIlbcL aCodecState: ",

        aCodecState )

    // Cannot change mode nor CNG state on fly, changing it only right after

    // the codec has been loaded. Same thing applies also to other parameters.

    if ( CMccSymStreamBase::EStateCodecLoaded == aCodecState )

        {

        CIlbcDecoderIntfc* decIlbcIf = 

            CIlbcDecoderIntfc::NewL( aPlaybackDev.SoundDevice() );

        CleanupStack::PushL( decIlbcIf );

        if( KIlbcBitrate1520 == aCodec.iBitrate )

            {

            __SUBCONTROLLER( "MccCodecConfigurator::DoConfigureIlbcL, 20ms" )

            User::LeaveIfError( decIlbcIf->SetDecoderMode(

                CIlbcDecoderIntfc::E20msFrame ) );

            }

        else if( KIlbcBitrate1333 == aCodec.iBitrate )

            {

            __SUBCONTROLLER( "MccCodecConfigurator::DoConfigureIlbcL, 30ms" )

            User::LeaveIfError( decIlbcIf->SetDecoderMode(

                CIlbcDecoderIntfc::E30msFrame ) );

            }

        else

            {

            User::Leave( KErrNotSupported );

            }

        TBool cngEnabled = ConvertBoolean( aCodec.iEnableDTX );

        MCC_CODEC_CONF_SET_VAD_L( currentVad,

	                              decIlbcIf->GetCng( currentVad ),

	                              cngEnabled, 

                        	      decIlbcIf->SetCng( cngEnabled ) ) 

        CleanupStack::PopAndDestroy( decIlbcIf );

        }

    __SUBCONTROLLER( "MccCodecConfigurator::DoConfigureIlbcL decoder, Exit" )

    }

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

// MccCodecConfigurator::DoConfigureIlbcL

// Configures the iLBC record device

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

//

void MccCodecConfigurator::DoConfigureIlbcL( 

    MMMFAudioInput& aRecordDev, 

    const TMccCodecInfo& aCodec,

    CMccSymStreamBase::TCodecState aCodecState )

    {

    __SUBCONTROLLER( "MccCodecConfigurator::DoConfigureIlbcL encoder" )

    __SUBCONTROLLER_INT1( "MccCodecConfigurator::DoConfigureIlbcL aCodecState: ",

        aCodecState )

    // Cannot change mode nor VAD state on fly, changing it only right after

    // the codec has been loaded. Same thing applies also to other parameters.

    if ( CMccSymStreamBase::EStateCodecLoaded == aCodecState )

        {

        CIlbcEncoderIntfc* encIlbcIf = 

            CIlbcEncoderIntfc::NewL( aRecordDev.SoundDevice() );

        CleanupStack::PushL( encIlbcIf );

        if( KIlbcBitrate1520 == aCodec.iBitrate )

            {

            __SUBCONTROLLER( "MccCodecConfigurator::DoConfigureIlbcL, 20ms" )

            User::LeaveIfError( encIlbcIf->SetEncoderMode(

                CIlbcEncoderIntfc::E20msFrame ) );

            }

        else if ( KIlbcBitrate1333 == aCodec.iBitrate )

            {

            __SUBCONTROLLER( "MccCodecConfigurator::DoConfigureIlbcL, 30ms" )

            User::LeaveIfError( encIlbcIf->SetEncoderMode(

                CIlbcEncoderIntfc::E30msFrame ) );

            }

        else

            {

            User::Leave( KErrNotSupported );

            }

        TBool vadEnabled = ConvertBoolean(  aCodec.iEnableDTX );

        MCC_CODEC_CONF_SET_VAD_L( currentVad,

	                              encIlbcIf->GetVadMode( currentVad ),

	                              vadEnabled, 

                        	      encIlbcIf->SetVadMode( vadEnabled ) )

        CleanupStack::PopAndDestroy( encIlbcIf );

        }

    __SUBCONTROLLER( "MccCodecConfigurator::DoConfigureIlbcL encoder, Exit" )

    }

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

// MccCodecConfigurator::DoConfigureCameraL

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

void MccCodecConfigurator::DoConfigureCameraL( CMccVideoSource& aVideoSource, 

    const TMccCodecInfo& aCodec )

	{