/*

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

*

*/

//  INTERNAL INCLUDES

#include "ut_musengreceivesession.h"

#include "musengstubs.h"

#include "musengtestdefs.h"

#include "musengreceivesession.h"

//  SYSTEM INCLUDES

#include <digia/eunit/eunitmacros.h>

#include <mceinsession.h>

#include <mcestreambundle.h>

#include <mcevideostream.h>

#include <mceaudiostream.h>

#include <mcertpsource.h>

#include <mcedisplaysink.h>

#include <mcespeakersink.h>

#include <mcecamerasource.h>

#include <mcefilesource.h>

#include <mcertpsink.h>

#include <mceaudiocodec.h>

#include <mceh263codec.h>

#include <mceavccodec.h>

#include <audiopreference.h>

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

//

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

//

UT_CMusEngReceiveSession* UT_CMusEngReceiveSession::NewL()

    {

    UT_CMusEngReceiveSession* self = UT_CMusEngReceiveSession::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

// 

UT_CMusEngReceiveSession* UT_CMusEngReceiveSession::NewLC()

    {

    UT_CMusEngReceiveSession* self = new( ELeave ) UT_CMusEngReceiveSession();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

//

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

//

UT_CMusEngReceiveSession::~UT_CMusEngReceiveSession()

    {

    // NOP

    }

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

// Default constructor

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

//

UT_CMusEngReceiveSession::UT_CMusEngReceiveSession()

    {

    // NOP

    }

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

// Second phase construct

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

//

void UT_CMusEngReceiveSession::ConstructL()

    {

    // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

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

//

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

//

void UT_CMusEngReceiveSession::SetupL(  )

    {

    }

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

//

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

//

void UT_CMusEngReceiveSession::Teardown(  )

    {

    delete iReceiveSession;

    }

// TEST HELPERS

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

//

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

//

CMceVideoStream* UT_CMusEngReceiveSession::ConstructVideoInStreamLC()

    {

    CMceVideoStream* videoStream = CMceVideoStream::NewLC();

    videoStream->SetSourceL( CMceRtpSource::NewLC() );

    CleanupStack::Pop();

    videoStream->AddSinkL( 

                CMceDisplaySink::NewLC( *iReceiveSession->iManager ) );

    CleanupStack::Pop();    

    return videoStream;

    }

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

//

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

//

CMceVideoStream* UT_CMusEngReceiveSession::ConstructVideoOutStreamLC()

    {

    CMceVideoStream* videoStream = CMceVideoStream::NewLC();    

    videoStream->SetSourceL( 

                CMceCameraSource::NewLC( *iReceiveSession->iManager ) );

    CleanupStack::Pop();

    videoStream->AddSinkL( CMceRtpSink::NewLC() );

    CleanupStack::Pop();

    return videoStream;

    }    

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

//

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

//   

CMceAudioStream* UT_CMusEngReceiveSession::ConstructAudioInStreamLC()

    {

    CMceAudioStream* audioStream = CMceAudioStream::NewLC();

    audioStream->SetSourceL( CMceRtpSource::NewLC() );

    CleanupStack::Pop();

    audioStream->AddSinkL( CMceSpeakerSink::NewLC() );

    CleanupStack::Pop();

    return audioStream;

    }

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

//

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

//   

CMceAudioStream* UT_CMusEngReceiveSession::ConstructAudioOutStreamLC()

    {

    CMceAudioStream* audioStream = CMceAudioStream::NewLC();

    audioStream->SetSourceL( 

        CMceFileSource::NewLC( *iReceiveSession->iManager, KNullDesC() ) );

    CleanupStack::Pop();

    audioStream->AddSinkL( CMceRtpSink::NewLC() );

    CleanupStack::Pop();

    return audioStream;

    }

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

// Helper to construct incoming sessions.

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

//

CMceInSession* UT_CMusEngReceiveSession::ConstructInSessionLC( 

                                             TInt aVideoStreamCount,

                                             TInt aAudioStreamCount,

                                             TBool aConstructSinks )

    {

    CMceInSession* inSession = CMceInSession::NewL( 

                                        *(iReceiveSession->iManager), 

                                        KTestOriginator() );

    CleanupStack::PushL( inSession );

    for ( TInt i = 0; i < aVideoStreamCount; ++i )

        {

        CMceVideoStream* videoStream = CMceVideoStream::NewLC();

        CMceRtpSource* rtpSource = CMceRtpSource::NewLC();

        videoStream->SetSourceL( rtpSource );

        CleanupStack::Pop( rtpSource );

        if ( aConstructSinks )

            {

            CMceDisplaySink* display = CMceDisplaySink::NewLC( 

                                                *(iReceiveSession->iManager) );

            videoStream->AddSinkL( display );

            CleanupStack::Pop( display );

            }

        inSession->AddStreamL( videoStream );

        CleanupStack::Pop( videoStream );

        }

    for ( TInt i = 0; i < aAudioStreamCount; ++i )

        {

        CMceAudioStream* audioStream = CMceAudioStream::NewLC();

        CMceRtpSource* rtpSource = CMceRtpSource::NewLC();

        audioStream->SetSourceL( rtpSource );

        CleanupStack::Pop( rtpSource );

        if ( aConstructSinks )

            {

            CMceSpeakerSink* speaker = CMceSpeakerSink::NewLC();

            audioStream->AddSinkL( speaker );

            CleanupStack::Pop( speaker );

            }

        inSession->AddStreamL( audioStream );

        CleanupStack::Pop( audioStream );

        }    

    return inSession;

    }

// TEST CASES

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

//

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

//

void UT_CMusEngReceiveSession::UT_NewLL(  )

    {

    EUNIT_ASSERT( iReceiveSession );

    EUNIT_ASSERT( !iReceiveSession->iSession );

    }

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

//

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

//

    {

    CMceInSession* inSession = ConstructInSessionLC( 1, 0 );

    iReceiveSession->IncomingSession( inSession, &container );

    CleanupStack::Pop( inSession );

    iReceiveSession->iSession->iState = CMceSession::EProceeding;

    inSession = ConstructInSessionLC( 1, 0 );

    iReceiveSession->IncomingSession( inSession, &container );

    CleanupStack::Pop( inSession );

    iReceiveSession->iSession->iState = CMceSession::EProceeding;

    iReceiveSession->iOperatorVariant = ETrue;

    inSession = ConstructInSessionLC( 1, 0 );

    iReceiveSession->IncomingSession( inSession, &container );

    CleanupStack::Pop( inSession );

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

//

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

//

void UT_CMusEngReceiveSession::UT_HandleSessionStateChangedL()

    {

    // Unknown session, let the base class handle 

    CMceInSession* inSession = ConstructInSessionLC( 1, 1 );

    iReceiveSession->HandleSessionStateChanged( *inSession, 0, KNullDesC8() );

    // Simulate incoming session

    TMceTransactionDataContainer container;

    iReceiveSession->IncomingSession( inSession, &container ); 

    CleanupStack::Pop( inSession );

    // Session is in state EReserving, let the base class handle

    iReceiveSession->HandleSessionStateChanged( *inSession, 0, KNullDesC8() );

    // The normal cases:

    // 1 ) First transition to state EProceeding, user and remote end should

    //     be notified

    iReceiveSession->HandleSessionStateChanged( *inSession, 0, KNullDesC8() );

    EUNIT_ASSERT( iReceiveSession->iRingLCalled )

    // 2 ) Now simulate second transition to EProceeding state which can happen

    //     if we force 100rel to be used. User and remote end should not be 

    //     notified anymore but change should be ignored.

    iReceiveSession->HandleSessionStateChanged( *inSession, 0, KNullDesC8() );

    }

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

//

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

// 

void UT_CMusEngReceiveSession::UT_AdjustVideoCodecLL()

    {

    CMceVideoCodec* codecH263 = CMceH263Codec::NewLC( KMceSDPNameH263() );    

    CMceVideoCodec* codecH2632000 = CMceH263Codec::NewLC( KMceSDPNameH2632000() );

    CMceVideoCodec* codecAvc = CMceAvcCodec::NewLC( KMceSDPNameH264() );

    CMceVideoCodec* codecUnknown = CMceH263Codec::NewLC( KNullDesC8() );

    EUNIT_ASSERT_EQUALS( codecH263->KeepAliveTimer(), 5 )

    EUNIT_ASSERT_EQUALS( codecH263->KeepAlivePayloadType(), 96 )

    EUNIT_ASSERT_EQUALS( codecH263->KeepAliveData(), KNullDesC8() )

    EUNIT_ASSERT_EQUALS( codecH2632000->KeepAliveTimer(), 5 )

    EUNIT_ASSERT_EQUALS( codecH2632000->KeepAlivePayloadType(), 96 )

    EUNIT_ASSERT_EQUALS( codecH2632000->KeepAliveData(), KNullDesC8() )

    EUNIT_ASSERT_EQUALS( codecAvc->KeepAliveTimer(), 5 )

    EUNIT_ASSERT_EQUALS( codecAvc->KeepAlivePayloadType(), 98 )

    EUNIT_ASSERT_EQUALS( codecAvc->KeepAliveData(), KNullDesC8() )

    EUNIT_ASSERT_EQUALS( codecUnknown->KeepAliveTimer(), 5 )

    EUNIT_ASSERT_EQUALS( codecUnknown->KeepAlivePayloadType(), 0 )

    EUNIT_ASSERT_EQUALS( codecUnknown->KeepAliveData(), KNullDesC8() )

    CleanupStack::PopAndDestroy( codecUnknown );

    CleanupStack::PopAndDestroy( codecAvc );

    CleanupStack::PopAndDestroy( codecH2632000 );

    CleanupStack::PopAndDestroy( codecH263 );

    }

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

//

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

// 

void UT_CMusEngReceiveSession::UT_AdjustAudioCodecLL()

    {

    CMceAudioCodec* codec = 

                iReceiveSession->iManager->SupportedAudioCodecs()[0]->CloneL();

    CleanupStack::PushL( codec );

    iReceiveSession->AdjustAudioCodecL( *codec );

    // Test keepalive timer

    TUint8 keepAliveTimer = codec->KeepAliveTimer();

    EUNIT_ASSERT( codec->KeepAliveTimer() == 5 )

    EUNIT_ASSERT( codec->KeepAlivePayloadType() == 97 )

    EUNIT_ASSERT( codec->KeepAliveData() == KNullDesC8() )

    // Test that base class has been called

    EUNIT_ASSERT( codec->iMMFPriority == KAudioPrioritySwisPlayback )

    EUNIT_ASSERT( codec->iMMFPriorityPreference == KAudioPrefSwisPlayback )

    CleanupStack::PopAndDestroy( codec );

    }

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

//

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

// 

void UT_CMusEngReceiveSession::UT_DoCodecSelectionLL()

    {    

    // Check that Non-Interleaved AVC is preferred over single NAL 

    CMceVideoStream* videoStream = CMceVideoStream::NewLC();

    CMceVideoCodec* codecAvcSingleNal = CMceAvcCodec::NewLC( KMceSDPNameH264() );

    codecAvcSingleNal->iCodecMode = KMceAvcModeSingleNal; 

    videoStream->AddCodecL( codecAvcSingleNal );

    CleanupStack::Pop( codecAvcSingleNal );

    CMceVideoCodec* codecAvcNonInterleaved = CMceAvcCodec::NewLC( KMceSDPNameH264() );

    codecAvcNonInterleaved->iCodecMode = KMceAvcModeNonInterleaved;

    videoStream->AddCodecL( codecAvcNonInterleaved );

    CleanupStack::Pop( codecAvcNonInterleaved );

    iReceiveSession->DoCodecSelectionL( *videoStream );

    EUNIT_ASSERT_EQUALS( videoStream->Codecs().Count(), 1 )

    EUNIT_ASSERT_EQUALS( videoStream->Codecs()[0]->SdpName(), KMceSDPNameH264() )

    EUNIT_ASSERT_EQUALS( videoStream->Codecs()[0]->CodecMode(),

                         KMceAvcModeNonInterleaved )

    CleanupStack::PopAndDestroy( videoStream );

    // Check that Single NAL AVC is preferred over H263

    videoStream = CMceVideoStream::NewLC();

    CMceVideoCodec* codecH263 = CMceH263Codec::NewLC( KMceSDPNameH263() );    

    videoStream->AddCodecL( codecH263 );

    CleanupStack::Pop( codecH263 );

    codecAvcSingleNal = CMceAvcCodec::NewLC( KMceSDPNameH264() );

    codecAvcSingleNal->iCodecMode = KMceAvcModeSingleNal; 

    videoStream->AddCodecL( codecAvcSingleNal );

    CleanupStack::Pop( codecAvcSingleNal );

    iReceiveSession->DoCodecSelectionL( *videoStream );

    EUNIT_ASSERT_EQUALS( videoStream->Codecs().Count(), 1 )

    EUNIT_ASSERT_EQUALS( videoStream->Codecs()[0]->SdpName(), KMceSDPNameH264() )

    EUNIT_ASSERT_EQUALS( videoStream->Codecs()[0]->CodecMode(),

                         KMceAvcModeSingleNal )

    CleanupStack::PopAndDestroy( videoStream );

    // Check that H263 codecs without AVC are handled correctly (in base class)

    videoStream = CMceVideoStream::NewLC();

    codecH263 = CMceH263Codec::NewLC( KMceSDPNameH263() );    

    videoStream->AddCodecL( codecH263 );

    CleanupStack::Pop( codecH263 );

    CMceVideoCodec* codecH2632000 = CMceH263Codec::NewLC( KMceSDPNameH2632000() );   

    videoStream->AddCodecL( codecH2632000 );

    CleanupStack::Pop( codecH2632000 );

    iReceiveSession->DoCodecSelectionL( *videoStream );

    EUNIT_ASSERT_EQUALS( videoStream->Codecs().Count(), 1 )

    CleanupStack::PopAndDestroy( videoStream );

    // Check that AVC non-interleaved with best bitrate is preferred

    videoStream = CMceVideoStream::NewLC();

    codecAvcNonInterleaved = CMceAvcCodec::NewLC( KMceSDPNameH264() );

    codecAvcNonInterleaved->iCodecMode = KMceAvcModeNonInterleaved;

    codecAvcNonInterleaved->SetMaxBitrateL( 80000 );