/*

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

    iDatapath( NULL ), 

    iEventhandler( aEventhandler ), 

    iMccResources( aMccResources ),

    iDatasink( NULL ), 

    iDatasource( NULL ), 

    iFmtpAttr( NULL ), 

    iRtpmanager( aManager ),

    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;

        }

    return type;

    }

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

// CMccSymStreamBase::LocalStream

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

//     

TBool CMccSymStreamBase::LocalStream() const

    {

    return ( iType == KMccVideoLocalStream || iType == KMccAudioLocalStream );

    }

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

// CMccSymStreamBase::StandbyStream

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

//     

TBool CMccSymStreamBase::StandbyStream() const

    {

    return ( iType == KMccAudioDownlinkStandbyStream );

    }

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

// CMccSymStreamBase::InformStreamStateChange

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

//   

void CMccSymStreamBase::InformStreamStateChange( 

    TMccEventType aEventType, TUint32 aEndpointId )

    {

    __SUBCONTROLLER_INT2( "CMccSymStreamBase::InformStreamStateChange, \

    aEventType=", aEventType, "aEndpointId=", aEndpointId )

    // Only state changes of mmf audio and uncontrolled endpoints (e.g. shared

    // ones which are already in state the client tried to set) are generated

    // at this level

    TBool isAudioOutput = ( iDatasink->DataSinkType() == KUidMmfAudioOutput );

    TBool isAudioInput = ( iDatasource->DataSourceType() == KUidMmfAudioInput );

    if ( iUncontrolledEndpoints.Count() > 0 )

        {

        __SUBCONTROLLER( "CMccSymStreamBase::InformStreamStateChange, \

        handle uncontrolled endpoints" )

        for ( TInt i = 0; i < iUncontrolledEndpoints.Count(); i++ )

            {  

            SendStreamEventToClient( aEventType, iUncontrolledEndpoints[ i ] );

            }

        }