/*

* 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:    Mcc Symmetric subthread stream baseclass

*

*/

// INCLUDE FILES

#include <mmf/server/sounddevice.h>

#include "mccsymstreambase.h"

#include "mccdatapathbase.h"

#include "mccinternaldef.h"

#include "mccsubcontrollerlogs.h"

#include "mccsymsubthreadclient.h"

#include "mccinternalevents.h"

#include "mmccevents.h"

#include "mccresources.h"

#include "mccmultiplexer.h"

#include "mccrtpdatasink.h"

#include "mccrtpdatasource.h"

#include "mmccinterface.h"

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

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

// CMccSymStreamBase::CMccSymStreamBase

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMccSymStreamBase::CMccSymStreamBase( 

    TUint32 aMccStreamId, 

    MAsyncEventHandler* aEventhandler, 

    MMccResources* aMccResources,

    CMccRtpManager* aManager, 

    TInt aStreamType ) : 

    iMsrpmanager( NULL ),

    iDatapath( NULL ), 

    iEventhandler( aEventhandler ), 

    iMccResources( aMccResources ),

    iDatasink( NULL ), 

    iDatasource( NULL ), 

    iFmtpAttr( NULL ), 

    iRtpmanager( aManager ),

    iSoundDevice( NULL ), 

    iMccStreamId( aMccStreamId ), 

    iType( aStreamType )

    {

    }

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

// CMccSymStreamBase::CMccSymStreamBase

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CMccSymStreamBase::CMccSymStreamBase( 

    TUint32 aMccStreamId, 

    MAsyncEventHandler* aEventhandler, 

    MMccResources* aMccResources,

    CMccMsrpManager* aManager, 

    TInt aStreamType ) : 

    iMsrpmanager( aManager ),

    iDatapath( NULL ), 

    iEventhandler( aEventhandler ), 

    iMccResources( aMccResources ),

    iDatasink( NULL ), 

    iDatasource( NULL ), 

    iFmtpAttr( NULL ), 

    iSoundDevice( NULL ), 

    iMccStreamId( aMccStreamId ), 

    iType( aStreamType )

    {

    }

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

// CMccSymStreamBase::~CMccSymStreamBase

// Destructor

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

//

CMccSymStreamBase::~CMccSymStreamBase()

    {

    HandleSpecialSinksAndSources();

    if( iDatasink )

        {

        iDatasink->SinkThreadLogoff();

        iDatasink = 0;

        }

    if( iDatapath )

        {

        delete iDatapath;

        iDatapath = 0;

        }

    if ( iFmtpAttr )

        {

        delete iFmtpAttr;

        iFmtpAttr = 0;

        }

	iControlledEndpoints.Reset();

	iUncontrolledEndpoints.Reset();

    }

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

// CMccSymStreamBase::SendEventToClient

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

//    

TInt CMccSymStreamBase::SendEventToClient( const TMMFEvent& aEvent )

	{

	TInt err( KErrNone );

	// Do in a bit ackward way in order to save stack memory

	TMccEvent* mccEventPtr = 0;

	if ( IS_MCC_EVENT( aEvent ) )

	    {

	    mccEventPtr = 

	        reinterpret_cast<const TMccInternalEvent&>( aEvent ).iMccEvent;                                     

	    }

	if ( mccEventPtr )

	    {	 

	    __SUBCONTROLLER( "CMccSymStreamBase::SendEventToClient #1" )

	    mccEventPtr->iStreamId = iMccStreamId;

    	err = iEventhandler->SendEventToClient( aEvent );	

	    }

	else

	    {

	    __SUBCONTROLLER( "CMccSymStreamBase::SendEventToClient #2" )

	    // Fill stream id for all MMF events and try to fill endpointId as well

	    TUint32 endpointId = ( iDatasink->DataSinkType() == KUidMmfAudioOutput ) ?

	         MCC_ENDPOINT_ID( iDatasink ) : 0;

        endpointId = ( iDatasource->DataSourceType() == KUidMmfAudioInput ) ?

            MCC_ENDPOINT_ID( iDatasource ) : endpointId;

	    err = SendStreamEventToClient( KMccStreamMMFEvent, endpointId, aEvent.iErrorCode );

	    }

	__SUBCONTROLLER( "CMccSymStreamBase::SendEventToClient, exit" )

    return err;

	}

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

// CMccSymStreamBase::MultiplexerSink

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

//

MDataSink* CMccSymStreamBase::MultiplexerSink()

    {

    return 0;

    }

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

// CMccSymStreamBase::SetStateL

// Sets the new state of the stream

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

//

TBool CMccSymStreamBase::SetStateL( TStreamState aState, TUint32 aEndpointId )

    {

    __SUBCONTROLLER( "CMccSymStreamBase::SetStateL" )

    TBool stateOK = EFalse;

    TBool controlNetworkResources = ETrue;

    MMccResources::TResourceState resourceState = MMccResources::EConstructed;

    switch( aState )

        {

        case EStateNone:

            __SUBCONTROLLER( "CMccSymStreamBase::SetStateL, EStateNone" )

            if( EStateStopped == iState )

                {

                resourceState = MMccResources::EConstructed;

                stateOK = ETrue;

                }

            break;

        case EStatePrepared:

            __SUBCONTROLLER( "CMccSymStreamBase::SetStateL, EStatePrepared" )

            resourceState = MMccResources::EPrepared;

            stateOK = ETrue;

            break;

        case EStateStreaming:

            __SUBCONTROLLER( "CMccSymStreamBase::SetStateL, EStateStreaming" )

            resourceState = MMccResources::EStarted;

            stateOK = ETrue;

            break;

        case EStatePaused:

            __SUBCONTROLLER( "CMccSymStreamBase::SetStateL, EStatePaused" )

            resourceState = MMccResources::EResourcePaused;

            stateOK = ETrue;

            break;

        case EStateStopped:

            __SUBCONTROLLER( "CMccSymStreamBase::SetStateL, EStateStopped" )

            resourceState = MMccResources::EResourceStopped;

            stateOK = ETrue;

            break;

        default:

            stateOK = EFalse;

            break;

        }

    __ASSERT_ALWAYS( stateOK, User::Leave( KErrArgument ) );

    if ( resourceState != MMccResources::EConstructed )

        {

        __SUBCONTROLLER( "CMccSymStreamBase::SetStateL, set resource state" )

        iControlledEndpoints.Reset();

        iUncontrolledEndpoints.Reset();

        iMccResources->SetResourceStateL( iMccStreamId,

                                          aEndpointId, 

                                          resourceState, 

                                          controlNetworkResources,

                                          iControlledEndpoints,

                                          iUncontrolledEndpoints );

        // Update multiplexer

        HandleMultiplexerL();

        // Update sink

        HandleSpecialSinksAndSources();

        }

    // Stream state follows network resource state or in case of

    // local stream any change affect to the stream state 

    if ( controlNetworkResources || LocalStream() )

        {

        iState = aState;

        }

    __SUBCONTROLLER( "CMccSymStreamBase::SetStateL, exit" )

    return controlNetworkResources;

    }

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

// CMccSymStreamBase::CurrentState

// Returns the current state of the stream

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

//

CMccSymStreamBase::TStreamState CMccSymStreamBase::CurrentState()

    {

    return iState;

    }

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

// CMccSymStreamBase::SetGainL

// Sets the current gain

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

//

void CMccSymStreamBase::SetGainL( TInt aGain )

    {

    if( iSoundDevice )

	    {

        iSoundDevice->SetGain( aGain );

        }

    }

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

// CMccSymStreamBase::SetVolumeL

// Sets the current volume

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

//

void CMccSymStreamBase::SetVolumeL( TInt aVolume )

    {

    if( iSoundDevice )

        {

        iSoundDevice->SetVolume( aVolume );

        }

    else if ( iDatasink && iDatasink->DataSinkType() == KMccVideoSinkUid )

        {

        CMccDataSink* sink = static_cast<CMccDataSink*>( iDatasink );

        sink->SetParameterL( KMccSpeakerVolume, TPckgBuf<TInt>( aVolume ) );

        }

    else

        {

        // NOP

        }

    }

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

// CMccSymStreamBase::SetVolumeL

// Sets the current volume

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

//

void CMccSymStreamBase::SetMMFPriority( 

                const TMMFPrioritySettings& aPriority )

	{

	__SUBCONTROLLER( "CMccSymStreamBase::SetPriorityToCodecsL entry " )

	//Check if the codec info priority is same otherwise don't do it

	if ( iPrioritySettings.iPref != aPriority.iPref ||

		 iPrioritySettings.iState != aPriority.iState ||

		 iPrioritySettings.iPriority != aPriority.iPriority )

		{

		__SUBCONTROLLER( " Different from privous setting " )

		TRAPD( err, SetPrioritySettingsL( aPriority ) );	

		__SUBCONTROLLER_INT1 ( " Setting priority preference to", aPriority.iPref );

		__SUBCONTROLLER_INT1 ( " Setting priority state to ", aPriority.iState );

		__SUBCONTROLLER_INT1 ( " Setting client priority to ", aPriority.iPriority );

		__SUBCONTROLLER_INT1 ( " SetPrioritySettingsL err =", err );

		if ( err == KErrNone )

			{

			iPrioritySettings = aPriority;

			}

		else

			{

			//Ignore error 

			__SUBCONTROLLER_INT1 ( " Sink or Source is not existed err =", err );

			err = KErrNone;

			}

		}

	__SUBCONTROLLER( "CMccSymStreamBase::SetPriorityToCodecsL exit " )

    }

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

// CMccSymStreamBase::MaxVolumeL

// Return the maximum volume

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

//

TInt CMccSymStreamBase::MaxVolumeL()

    {

    if( iSoundDevice )

        {

        return iSoundDevice->MaxVolume();

        }

    return KErrNone;    

    }

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

// CMccSymStreamBase::MaxGainL

// Return the maximum gain

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

//

TInt CMccSymStreamBase::MaxGainL()

    {

    if( iSoundDevice )

        {

        return iSoundDevice->MaxGain();

        }

    return KErrNone;    

    }

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

// CMccSymStreamBase::VolumeL

// Return the current volume

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

//

TInt CMccSymStreamBase::VolumeL()

    {

    if( iSoundDevice )

        {

        return iSoundDevice->Volume();

        }

    return KErrNone;    

    }

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

// CMccSymStreamBase::GainL

// Return the current gain

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

//

TInt CMccSymStreamBase::GainL()

    {

    if( iSoundDevice )

        {

        return iSoundDevice->Gain();

        }

    return KErrNone;    

    }

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

// CMccSymStreamBase::SendMediaSignalL

// Default implementation of media signal sending

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

//

void CMccSymStreamBase::SendMediaSignalL( const TMccEvent& /*aEvent*/ )

    {

    User::Leave( KErrNotSupported );

    }

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

// CMccSymStreamBase::SendRTCPReceiverReportL

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

// 

void CMccSymStreamBase::SendRTCPReceiverReportL()

    {

    User::Leave( KErrNotSupported );

    }

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

// CMccSymStreamBase::SendRTCPSenderReportL

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

// 

void CMccSymStreamBase::SendRTCPSenderReportL()

    {

    User::Leave( KErrNotSupported );

    }

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

// CMccSymStreamBase::SendRTCPDataL

// Sends Non-RTCP data

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

// 

void CMccSymStreamBase::SendRTCPDataL( const TDesC8& /*aData*/ )

    {

    User::Leave( KErrNotSupported );

    }

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

// CMccSymStreamBase::StartInactivityTimerL

// Starts inactivity timer for a stream

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

// 

void CMccSymStreamBase::StartInactivityTimerL( TUint32 /*aTimeoutTime*/ )

    {

    User::Leave( KErrNotSupported );

    }

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

// CMccSymStreamBase::StopInactivityTimerL

// Stops inactivity timer for a stream 

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

// 

void CMccSymStreamBase::StopInactivityTimerL()

    {

    User::Leave( KErrNotSupported );

    }

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

// CMccSymStreamBase::GetFmtpL

// Fetches the FMTP attribute

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

// 

void CMccSymStreamBase::GetFmtpL( TDes8& aFmtp )

    {

    __ASSERT_ALWAYS ( iFmtpAttr, User::Leave(KErrArgument) );

	aFmtp.Copy( iFmtpAttr->Des() );

    }

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

// CMccSymStreamBase::GetCodecL

// Fetches codec info

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

// 

void CMccSymStreamBase::GetCodecL( TMccCodecInfo& aCodec )

    {

    aCodec = iCodecInfo;

    }

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

// CMccSymStreamBase::SetAudioRouteL

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

//    

void CMccSymStreamBase::SetAudioRouteL( TUint32 /*aRoutingDestination*/ )

    {

    User::Leave( KErrNotSupported );

    }

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

// CMccSymStreamBase::GetAudioRouteL

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

//     

void CMccSymStreamBase::GetAudioRouteL( TUint32& /*aRoutingDestination*/ )

    {

    User::Leave( KErrNotSupported );

    }

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

// CMccSymStreamBase::Type

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

//     

const TUid CMccSymStreamBase::Type()

    {

    TUid type = KUidMediaTypeAudio;

    if (iType == KMccVideoUplinkStream ||

        iType == KMccVideoDownlinkStream ||

        iType == KMccVideoLocalStream )

        {

        type = KUidMediaTypeVideo;

        }

    else if (iType == KMccMessageUplinkStream)

        {

        static const TUid KUidMediaTypeMessage    = {0x10289999};  //KImplUidMsrpPayloadFormatEncode

        type = KUidMediaTypeMessage;

        }

    else if (iType == KMccMessageDownlinkStream)

        {

        static const TUid KUidMediaTypeMessage    = {0x10288888};  //KImplUidMsrpPayloadFormatDecode

        type = KUidMediaTypeMessage;

        }

    return type;

    }

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