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




//  CLASS HEADER
#include "UT_CMccCodecConfigurator.h"

//  EXTERNAL INCLUDES
#include <digia/eunit/EUnitMacros.h>
#include <mmf/server/mmfaudioinput.h>
#include <mmf/plugin/mmfaudioiointerfaceuids.hrh>

//  INTERNAL INCLUDES
#include "mcccodecconfigurator.h"
#include "Mccinternalcodecs.h"
#include "FormatStateMachine.h"
#include <mmf/server/mmfformat.h>
#include "mccrtpmediaclock.h"
#include "mmccinterfacedef.h"
#include "mccunittestmacros.h"
#include "mccinternaldef.h"
#include "mccgenericdatasink_STUB.h"
#include "mccgenericdatasource_STUB.h"
#include "mccfilesink.h"

// CONSTRUCTION
UT_CMccCodecConfigurator* UT_CMccCodecConfigurator::NewL()
    {
    UT_CMccCodecConfigurator* self = UT_CMccCodecConfigurator::NewLC();
    CleanupStack::Pop();

    return self;
    }

UT_CMccCodecConfigurator* UT_CMccCodecConfigurator::NewLC()
    {
    UT_CMccCodecConfigurator* self = new( ELeave ) UT_CMccCodecConfigurator();
    CleanupStack::PushL( self );

    self->ConstructL();

    return self;
    }

// Destructor (virtual by CBase)
UT_CMccCodecConfigurator::~UT_CMccCodecConfigurator()
    {
    }

// Default constructor
UT_CMccCodecConfigurator::UT_CMccCodecConfigurator()
    {
    }

// Second phase construct
void UT_CMccCodecConfigurator::ConstructL()
    {
    // The ConstructL from the base class CEUnitTestSuiteClass must be called.
    // It generates the test case table.
    CEUnitTestSuiteClass::ConstructL();
    }

//  METHODS

void UT_CMccCodecConfigurator::SetupL()
    {
    iRtpMediaClock = CMccRtpMediaClock::NewL();
    }

void UT_CMccCodecConfigurator::Teardown()
    {
    delete iRtpMediaClock;
    }

void UT_CMccCodecConfigurator::UT_CMccCodecConfigurator_ConfigureCodecLL()
    {
    TMccCodecInfo cInfo;

    // These two will fail because of the NULL    
    //EUNIT_ASSERT_LEAVE( CMccCodecConfigurator::ConfigureCodecL( NULL, reinterpret_cast<MDataSink&>( *this ), cInfo, *iRtpMediaClock ) );
    //EUNIT_ASSERT_LEAVE( CMccCodecConfigurator::ConfigureCodecL( reinterpret_cast<MDataSource&>( *this ), NULL, cInfo, *iRtpMediaClock ) );
    }

void UT_CMccCodecConfigurator::UT_CMccCodecConfigurator_DoConfigureAmrNbLL()
    {
    // aPlaybackDev == NULL
    /*EUNIT_ASSERT_LEAVE( CMccCodecConfigurator::DoConfigureAmrNbL(
        static_cast<MMMFAudioOutput&>( NULL ), KAmrNbBitrate475, EFalse ) );*/

    // AMR-NB
    TMccCodecInfo codecInfo;
    codecInfo.iFourCC = KMccFourCCIdAMRNB;
    codecInfo.iBitrate = 42;
    // Wrong bitrate
    EUNIT_ASSERT_LEAVE( MccCodecConfigurator::DoConfigureAmrL(
        reinterpret_cast<MMMFAudioOutput&>( *this ), codecInfo ) );
    
    // AMR-WB    
    codecInfo.iFourCC = KMccFourCCIdAMRWB;
    // Wrong bitrate
    EUNIT_ASSERT_LEAVE( MccCodecConfigurator::DoConfigureAmrL(
        reinterpret_cast<MMMFAudioOutput&>( *this ), codecInfo ) );
    }

void UT_CMccCodecConfigurator::UT_CMccCodecConfigurator_DoConfigureAmrNbL2L()
    {
    // aRecordDev == NULL
    /*EUNIT_ASSERT_LEAVE( CMccCodecConfigurator::DoConfigureAmrNbL(
        static_cast<MMMFAudioInput&>( NULL ), KAmrNbBitrate475, EFalse ) );*/
    }

void UT_CMccCodecConfigurator::UT_CMccCodecConfigurator_DoConfigureUplinkStreamLL()
    {
    TMccCodecInfo codec;
    
    // aRecordDevice == NULL
    /*EUNIT_ASSERT_LEAVE( CMccCodecConfigurator::DoConfigureLiveAudioUplinkStreamL(
        static_cast<MMMFAudioInput&>( NULL ),
        NULL,
        codec ) );*/

    // aFormatter == NULL
    /*EUNIT_ASSERT_LEAVE( CMccCodecConfigurator::DoConfigureLiveAudioUplinkStreamL(
        reinterpret_cast<MMMFAudioInput*>( this ),
        NULL,
        codec ) );*/

    // wrong codec
    EUNIT_ASSERT_LEAVE( MccCodecConfigurator::DoConfigureLiveAudioUplinkStreamL(
        reinterpret_cast<MMMFAudioInput&>( *this ),
        reinterpret_cast<CPayloadFormatWrite&>( *this ),
        codec,
        *iRtpMediaClock,
        CMccSymStreamBase::EStateCodecLoaded ) );
    }

void UT_CMccCodecConfigurator::UT_CMccCodecConfigurator_DoConfigureDownlinkStreamLL()
    {
    TMccCodecInfo codec;
    
    // aPlayDevice == NULL
    /*EUNIT_ASSERT_LEAVE( CMccCodecConfigurator::DoConfigureLiveAudioDownlinkStreamL(
        static_cast<MMMFAudioOutput*>( NULL ),
        NULL,
        codec ) );*/

    // aFormatter == NULL
    /*EUNIT_ASSERT_LEAVE( CMccCodecConfigurator::DoConfigureLiveAudioDownlinkStreamL(
        reinterpret_cast<MMMFAudioOutput*>( this ),
        NULL,
        codec ) );*/

    // wrong codec
    EUNIT_ASSERT_LEAVE( MccCodecConfigurator::DoConfigureLiveAudioDownlinkStreamL(
        reinterpret_cast<MMMFAudioOutput&>( *this ),
        reinterpret_cast<CPayloadFormatRead&>( *this ),
        codec,
        CMccSymStreamBase::EStateCodecLoaded ) );
    }

void UT_CMccCodecConfigurator::UT_CMccCodecConfigurator_DoGetClipConfigurationLL()
    {
    TMccFileSourceSetting settings;
    
    // File not found
    settings.iFileName = _L("c:\\testfilecannotbefound.3gp");
    TMccFileSourceSettingBuf settingsBuf( settings );
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( 
        MccCodecConfigurator::DoGetClipConfigurationL( settingsBuf ), KErrNotFound );
    
    // File contains audio and video
    settings.iFileName = _L("c:\\CrazyFrog.3gp");
    settingsBuf = settings;
    
    TRAPD( err, MccCodecConfigurator::DoGetClipConfigurationL( settingsBuf ));
    if ( err == KErrNotFound )
        {
    	User::Leave( KErrNoMemory ); // MP4 lib gives file errors when out of mem
        }
    else if ( err != KErrNone )
        {
        User::Leave( err );
        }
    
    settings = settingsBuf();
    
    // FourCC value is not set when running out of memory.    
    if ( settings.iAudioFourCC == TFourCC() ||
         settings.iVideoFourCC == TFourCC() )
        {
        return;
        }   
    
    EUNIT_ASSERT( settings.iAudioFourCC == TFourCC( KMccFourCCIdAMRNB ) );
    EUNIT_ASSERT( settings.iVideoFourCC == TFourCC( KMccFourCCIdH263 ) );
    
    TMccFileSourceSetting settings2;
    settings2.iFileName = _L("c:\\test_avc.3gp");
    settingsBuf = settings2;
    
    TRAP( err, MccCodecConfigurator::DoGetClipConfigurationL( settingsBuf ));
    if ( err == KErrNotFound )
        {
    	User::Leave( KErrNoMemory ); // MP4 lib gives file errors when out of mem
        }
    else if ( err != KErrNone )
        {
        User::Leave( err );
        }
    
    settings2 = settingsBuf();
    
    // FourCC value is not set when running out of memory.    
    if ( settings2.iVideoFourCC == TFourCC() )
        {
        return;
        }   
    
    EUNIT_ASSERT( settings2.iVideoFourCC == TFourCC( KMccFourCCIdAVC ) );
    }

void UT_CMccCodecConfigurator::UT_CMccCodecConfigurator_PassPrerollFromSinkToSourceLL()
    {
    CMccGenericDataSource* dataSource = new ( ELeave ) CMccGenericDataSource( KMccFileSourceUid );
    CleanupStack::PushL( dataSource );
    CMccGenericDataSink* dataSink = new ( ELeave ) CMccGenericDataSink( KMccVideoSinkUid );
    CleanupStack::PushL( dataSink );

//    CMccFileSource* dataSource = new CMccFileSource();
//    dataSource->iSourceImpl = CMccFileSourceImpl::NewL( 0 );

    // Should return immediately
    MccCodecConfigurator::PassPrerollFromSinkToSourceL(
        reinterpret_cast<MDataSink*>( NULL ), (MDataSource *)dataSource );
    // Should return immediately
    MccCodecConfigurator::PassPrerollFromSinkToSourceL(
        (MDataSink *)dataSink, reinterpret_cast<MDataSource*>( NULL ) );

    TInt preroll = 346;
    TPckgBuf<TInt> packageBuffer = preroll;
    dataSink->SetParameterL( KMccPrerollTime, packageBuffer );

    MccCodecConfigurator::PassPrerollFromSinkToSourceL(
        (MDataSink *)dataSink, (MDataSource *)dataSource );
        
//    EUNIT_ASSERT( dataSource->iSourceImpl->DelayAfterStop() == KMccMinPreroll ); // KMccMinPreroll = 2000
    packageBuffer = 0;
    dataSource->GetParameterL( KMccPrerollTime, packageBuffer );
    EUNIT_ASSERT( packageBuffer() == 346 );

    CleanupStack::Pop( dataSink );
    CleanupStack::Pop( dataSource );
    delete dataSink;
    delete dataSource;
    }


void UT_CMccCodecConfigurator::UT_MccCodecConfigurator_IlbcNeedsStopResumeL()
    {
    TInt origBr = 13300;
    TInt newBr = 15200;
    TFourCC fcc;
    EUNIT_ASSERT( MccCodecConfigurator::IlbcNeedsStopResume( origBr, newBr, fcc ) == EFalse );
    
    fcc = KMccFourCCIdILBC;
    EUNIT_ASSERT( MccCodecConfigurator::IlbcNeedsStopResume( origBr, newBr, fcc ) == ETrue );
    EUNIT_ASSERT( MccCodecConfigurator::IlbcNeedsStopResume( origBr, origBr, fcc ) == EFalse );
    EUNIT_ASSERT( MccCodecConfigurator::IlbcNeedsStopResume( newBr, newBr, fcc ) == EFalse );
    
    fcc = KMccFourCCIdAMRNB;
    EUNIT_ASSERT( MccCodecConfigurator::IlbcNeedsStopResume( origBr, newBr, fcc ) == EFalse );
    EUNIT_ASSERT( MccCodecConfigurator::IlbcNeedsStopResume( origBr, origBr, fcc ) == EFalse );
    EUNIT_ASSERT( MccCodecConfigurator::IlbcNeedsStopResume( newBr, newBr, fcc ) == EFalse );
    }
    
void UT_CMccCodecConfigurator::UT_MccCodecConfigurator_VadWithoutComfortNoiseL()
    {
    // Actually this test does not really work because CI's are not implemented
    // in WINSCW. But, basic skeleton case implemented here so that it can be
    // easily brought in action in case of working WINSCW CI's.
    TUid inputUid = TUid::Uid( KMmfUidAudioInputInterface );
    MDataSource* recordDevice = MDataSource::NewSourceL( inputUid, KNullDesC8 );
    CleanupDeletePushL( recordDevice );
    recordDevice->SourceThreadLogon( *this );
    
    MMMFAudioInput* tmp = static_cast<MMMFAudioInput*>( recordDevice );
    
    TMccCodecInfo info;
    info.iFourCC = KMccFourCCIdILBC;
    info.iComfortNoiseGenerationPt = KPayloadTypeUndefined;
    info.iEnableDTX = ETrue;
    
    MCC_EUNIT_ASSERT_NO_LEAVE( 
        MccCodecConfigurator::DoConfigureIlbcL( *tmp, info, CMccSymStreamBase::EStateCodecPrepared ) );
    
    info.iComfortNoiseGenerationPt = 13;
    
    MCC_EUNIT_ASSERT_NO_LEAVE( 
        MccCodecConfigurator::DoConfigureIlbcL( *tmp, info, CMccSymStreamBase::EStateCodecPrepared ) );
    
    info.iFourCC = KMccFourCCIdG711;
    info.iComfortNoiseGenerationPt = KPayloadTypeUndefined;
    info.iEnableDTX = ETrue;
    
    recordDevice->SourceThreadLogoff();
    User::LeaveIfError( recordDevice->SourceThreadLogon( *this ) );
    
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( 
        MccCodecConfigurator::DoConfigureG711L( *tmp, info, CMccSymStreamBase::EStateCodecPrepared ),
        KErrNone ); // Was KErrNotFound, but stub return KErrNone. Not sure about hw.
    
    recordDevice->SourceThreadLogoff();
    CleanupStack::PopAndDestroy( recordDevice );
    }

void UT_CMccCodecConfigurator::UT_MccCodecConfigurator_DoConfigureFileSinkL()
    {
    CMccFileSink* fileSink = static_cast<CMccFileSink*>( CMccFileSink::NewSinkL( KNullUid, KNullDesC8 ) );
    CleanupStack::PushL( fileSink );
    TMccCodecInfo videoCodec;
    videoCodec.iType = KUidMediaTypeVideo;
    videoCodec.iFourCC = KMccFourCCIdAVC;
    MccCodecConfigurator::DoConfigureFileSinkL( *fileSink, videoCodec );
    EUNIT_ASSERT( fileSink->SinkDataTypeCode( KUidMediaTypeVideo ) == KMccFourCCIdAVC );
    
    TMccCodecInfo audioCodec;
    audioCodec.iType = KUidMediaTypeAudio;
    audioCodec.iFourCC = KMccFourCCIdG711;
    MccCodecConfigurator::DoConfigureFileSinkL( *fileSink, audioCodec );
    EUNIT_ASSERT( fileSink->SinkDataTypeCode( KUidMediaTypeAudio ) == KMccFourCCIdG711 );
    CleanupStack::PopAndDestroy( fileSink );
    }
    
//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE(
    UT_CMccCodecConfigurator,
    "Add test suite description here.",
    "UNIT" )

EUNIT_TEST(
    "ConfigureCodecL - test ",
    "CMccCodecConfigurator",
    "ConfigureCodecL",
    "FUNCTIONALITY",
    SetupL, UT_CMccCodecConfigurator_ConfigureCodecLL, Teardown)

EUNIT_TEST(
    "DoConfigureAmrNbL - test ",
    "CMccCodecConfigurator",
    "DoConfigureAmrNbL",
    "FUNCTIONALITY",
    SetupL, UT_CMccCodecConfigurator_DoConfigureAmrNbLL, Teardown)

EUNIT_TEST(
    "DoConfigureAmrNbL2 - test ",
    "CMccCodecConfigurator",
    "DoConfigureAmrNbL2",
    "FUNCTIONALITY",
    SetupL, UT_CMccCodecConfigurator_DoConfigureAmrNbL2L, Teardown)

EUNIT_TEST(
    "DoConfigureUplinkStreamL - test ",
    "CMccCodecConfigurator",
    "DoConfigureUplinkStreamL",
    "FUNCTIONALITY",
    SetupL, UT_CMccCodecConfigurator_DoConfigureUplinkStreamLL, Teardown)

EUNIT_TEST(
    "DoConfigureDownlinkStreamL - test ",
    "CMccCodecConfigurator",
    "DoConfigureDownlinkStreamL",
    "FUNCTIONALITY",
    SetupL, UT_CMccCodecConfigurator_DoConfigureDownlinkStreamLL, Teardown)

EUNIT_TEST(
    "DoGetClipConfigurationL - test ",
    "CMccCodecConfigurator",
    "DoGetClipConfigurationL",
    "FUNCTIONALITY",
    SetupL, UT_CMccCodecConfigurator_DoGetClipConfigurationLL, Teardown)
    
EUNIT_TEST(
    "PassPrerollFromSinkToSourceL - test ",
    "CMccCodecConfigurator",
    "PassPrerollFromSinkToSourceL",
    "FUNCTIONALITY",
    SetupL, UT_CMccCodecConfigurator_PassPrerollFromSinkToSourceLL, Teardown)

EUNIT_TEST(
    "IlbcNeedsStopResume - test ",
    "CMccCodecConfigurator",
    "IlbcNeedsStopResume",
    "FUNCTIONALITY",
    SetupL, UT_MccCodecConfigurator_IlbcNeedsStopResumeL, Teardown)

EUNIT_TEST(
    "VadWithoutComfortNoiser - test ",
    "CMccCodecConfigurator",
    "VadWithoutComfortNoise",
    "FUNCTIONALITY",
    SetupL, UT_MccCodecConfigurator_VadWithoutComfortNoiseL, Teardown)

EUNIT_TEST(
    "DoConfigureFileSinkL - test ",
    "CMccCodecConfigurator",
    "DoConfigureFileSinkL",
    "FUNCTIONALITY",
    SetupL, UT_MccCodecConfigurator_DoConfigureFileSinkL, Teardown)

EUNIT_END_TEST_TABLE

//  END OF FILE