diff -r 000000000000 -r 1bce908db942 multimediacommscontroller/mmccsubcontroller/src/mccsymstreambase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/multimediacommscontroller/mmccsubcontroller/src/mccsymstreambase.cpp Tue Feb 02 01:04:58 2010 +0200 @@ -0,0 +1,947 @@ +/* +* 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 +#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( 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( iDatasink ); + sink->SetParameterL( KMccSpeakerVolume, TPckgBuf( 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 ] ); + } + } + else if ( iCodecInfo.iType == KUidMediaTypeAudio && + ( isAudioOutput || isAudioInput ) ) + { + __SUBCONTROLLER( "CMccSymStreamBase::InformStreamStateChange, \ + report state change" ) + + if ( MCC_CONTROL_ALL_ENDPOINTS( aEndpointId ) ) + { + // Modify endpoint id + aEndpointId = isAudioOutput ? MCC_ENDPOINT_ID( iDatasink ) : + MCC_ENDPOINT_ID( iDatasource ); + + SendStreamEventToClient( aEventType, aEndpointId ); + } + else if ( ( aEndpointId == MCC_ENDPOINT_ID( iDatasink ) && isAudioOutput ) || + ( aEndpointId == MCC_ENDPOINT_ID( iDatasource ) && isAudioInput ) ) + { + // MMF endpoint is specificly controlled + SendStreamEventToClient( aEventType, aEndpointId ); + } + else + { + __SUBCONTROLLER("CMccSymStreamBase::InformStreamStateChange, not reported") + } + } + else + { + __SUBCONTROLLER("CMccSymStreamBase::InformStreamStateChange, not reported") + } + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::HandleStandby +// If stream is paused and standby endpoint (speaker) is controlled, +// standby is activated as we want that it will be resumed when receiving +// data for this stream. If stream is playing but standby endpoint control +// is non-effective, standby mechanism is re-activated in order to get the +// standby resource later into use (this scenario might occur if client has +// paused the speaker while standby occurs). +// ----------------------------------------------------------------------------- +// +void CMccSymStreamBase::HandleStandby( + TUint32 aEndpointId, + TBool aStreamPaused ) + { + TUint32 standbyEndpointId( MCC_ENDPOINT_ID( iDatasink ) ); + TBool standbyEndpointControl( StandbyStream() && + ( aEndpointId == standbyEndpointId || + MCC_CONTROL_ALL_ENDPOINTS( aEndpointId ) ) ); + + TBool isStandbyEndpointControlled( IsControlled( standbyEndpointId ) ); + + if ( standbyEndpointControl && + ( ( aStreamPaused && isStandbyEndpointControlled ) || + ( !aStreamPaused && !isStandbyEndpointControlled ) ) ) + { + CMccRtpDataSource* dSource = static_cast( iDatasource ); + dSource->StandBy( EActivateStandby, iCodecInfo.iPayloadType ); + } + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::SendStreamEventToClient +// ----------------------------------------------------------------------------- +// +TInt CMccSymStreamBase::SendStreamEventToClient( + TMccEventType aEventType, + TUint32 aEndpointId, + TInt aError ) + { + ClearStateChangeEvent(); + + iStreamStateChangeEvent.iStreamId = iMccStreamId; + iStreamStateChangeEvent.iEndpointId = aEndpointId; + iStreamStateChangeEvent.iEventCategory = KMccEventCategoryStream; + iStreamStateChangeEvent.iEventType = aEventType; + iStreamStateChangeEvent.iErrorCode = aError; + + TMccInternalEvent internalEvent( Type(), + EMccInternalEventNone, + iStreamStateChangeEvent ); + + return iEventhandler->SendEventToClient( internalEvent ); + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::HandleMultiplexerL +// ----------------------------------------------------------------------------- +// +void CMccSymStreamBase::HandleMultiplexerL() + { + __SUBCONTROLLER( "CMccSymStreamBase::HandleMultiplexerL" ) + + if ( iMultiplexer ) + { + MDataSink* multiplexerSink = MultiplexerSink(); + if ( multiplexerSink ) + { + iMultiplexer->SetCurrentUserL( *multiplexerSink ); + } + } + + __SUBCONTROLLER( "CMccSymStreamBase::HandleMultiplexerL, exit" ) + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::HandleSpecialSinksAndSources +// ----------------------------------------------------------------------------- +// +void CMccSymStreamBase::HandleSpecialSinksAndSources() + { + if ( iDatasink && + ( iDatasink->DataSinkType() == KUidMccVideoSink || + iDatasink->DataSinkType() == KUidMccRtpSink || + iDatasink->DataSinkType() == KUidMccFileSink ) ) + { + static_cast( iDatasink )->SetCurrentUser( this ); + } + + if ( iDatasource && iDatasource->DataSourceType() == KUidMccVideoSource ) + { + static_cast( iDatasource )->SetCurrentUser( this ); + } + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::MultiplexerCleanup +// ----------------------------------------------------------------------------- +// +void CMccSymStreamBase::MultiplexerCleanup() + { + // If multiplexer exists, sourcethread logoff is routed through it to the + // datasource + if ( iMultiplexer ) + { + iMultiplexer->MultiplexerSourceThreadLogoff( MultiplexerSink() ); + iMultiplexer = 0; + } + else if ( iDatasource ) + { + iDatasource->SourceThreadLogoff(); + iDatasource = 0; + } + else + { + // NOP + } + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::DoPrimeL +// ----------------------------------------------------------------------------- +// +void CMccSymStreamBase::DoPrimeL() + { + for ( TInt i = 0; i < iControlledEndpoints.Count(); i++ ) + { + iDatapath->PrimeL( iControlledEndpoints[ i ] ); + } + + iMccResources->ResourceStateSetL(); + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::DoPlayL +// ----------------------------------------------------------------------------- +// +void CMccSymStreamBase::DoPlayL() + { + for ( TInt i = 0; i < iControlledEndpoints.Count(); i++ ) + { + iDatapath->PlayL( iControlledEndpoints[ i ] ); + } + + iMccResources->ResourceStateSetL(); + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::DoPauseL +// ----------------------------------------------------------------------------- +// +void CMccSymStreamBase::DoPauseL() + { + for ( TInt i = 0; i < iControlledEndpoints.Count(); i++ ) + { + iDatapath->PauseL( iControlledEndpoints[ i ] ); + } + + iMccResources->ResourceStateSetL(); + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::DoResumeL +// ----------------------------------------------------------------------------- +// +void CMccSymStreamBase::DoResumeL() + { + for ( TInt i = 0; i < iControlledEndpoints.Count(); i++ ) + { + iDatapath->ResumeL( iControlledEndpoints[ i ] ); + } + + iMccResources->ResourceStateSetL(); + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::DoStopL +// ----------------------------------------------------------------------------- +// +void CMccSymStreamBase::DoStopL() + { + for ( TInt i = 0; i < iControlledEndpoints.Count(); i++ ) + { + iDatapath->StopL( iControlledEndpoints[ i ] ); + } + + iMccResources->ResourceStateSetL(); + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::ParsePayloadTypesL +// ----------------------------------------------------------------------------- +// +void CMccSymStreamBase::ParsePayloadTypesL( RArray& aPayloadTypes, + const TMccCodecInfo& aCodecInfo ) const + { + __ASSERT_DEBUG( KMccPayloadTypeMax != aCodecInfo.iPayloadType, + User::Panic( _L("PT PARSE, PT NOT SET"), KErrArgument ) ); + + aPayloadTypes.AppendL( aCodecInfo.iPayloadType ); + + if ( KMccPayloadTypeMax != aCodecInfo.iRedundantPayload ) + { + aPayloadTypes.AppendL( aCodecInfo.iRedundantPayload ); + } + + + if ( KPayloadTypeUndefined != aCodecInfo.iComfortNoiseGenerationPt && + aCodecInfo.iEnableDTX ) + { + aPayloadTypes.AppendL( KCnPayloadType ); + aPayloadTypes.AppendL( KCnPayloadTypeReserved ); + } + } + + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::IsControllingMmfEndpoint +// ----------------------------------------------------------------------------- +// +TBool CMccSymStreamBase::IsControllingMmfEndpoint() const + { + TBool controlling( EFalse ); + for ( TInt i = 0; i < iControlledEndpoints.Count() && !controlling; i++ ) + { + TUint32 endpointId = iControlledEndpoints[ i ]; + controlling = + MCC_CONTROL_ALL_ENDPOINTS( endpointId ) || + ( iDatasink->DataSinkType() == KUidMmfAudioOutput && + endpointId == MCC_ENDPOINT_ID( iDatasink ) ) || + ( iDatasource->DataSourceType() == KUidMmfAudioInput && + endpointId == MCC_ENDPOINT_ID( iDatasource ) ); + + } + return controlling; + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::IsCodecOperationAllowed +// ----------------------------------------------------------------------------- +// +TBool CMccSymStreamBase::IsCodecOperationAllowed() const + { + TBool allowed( ETrue ); + + if ( iDatasink->DataSinkType() == KUidMmfAudioOutput || + iDatasource->DataSourceType() == KUidMmfAudioInput ) + { + allowed = IsControllingMmfEndpoint(); + } + + return allowed; + + } + + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::CurrentCodecState +// ----------------------------------------------------------------------------- +// +CMccSymStreamBase::TCodecState CMccSymStreamBase::CurrentCodecState() const + { + return iCodecState; + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::SetCodecState +// ----------------------------------------------------------------------------- +// + +void CMccSymStreamBase::SetCodecState( TCodecState aState ) + { + iCodecState = aState; + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::UpdateCodecLoadingPermission +// ----------------------------------------------------------------------------- +// +void CMccSymStreamBase::UpdateCodecLoadingPermission( TBool aLoadingAllowed ) + { + iCodecLoadingAllowed = aLoadingAllowed; + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::CodecLoadingAllowed +// ----------------------------------------------------------------------------- +// +TBool CMccSymStreamBase::CodecLoadingAllowed() const + { + return iCodecLoadingAllowed; + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::ChangeBitrate +// Traps the call to dynamic bitrate change function +// ----------------------------------------------------------------------------- +// +TInt CMccSymStreamBase::ChangeBitrate( TInt aBitrate ) + { + TRAPD( err, this->DoChangeBitrateL( aBitrate ) ); + + // If the bitrate change is not supported, we may just suppress the error + // as this function may have been called to e.g a dl stream. + if( KErrNotSupported == err ) + { + __SUBCONTROLLER( "CMccSymStreamBase::ChangeBitrate KErrNotSupported" ); + return KErrNone; + } + else + { + // Something else has happened, maybe bitrate was wrong, so report it + // back + __SUBCONTROLLER_INT1( "CMccSymStreamBase::ChangeBitrate ERROR:", err ); + return err; + } + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::DoChangeBitrateL +// Downlink cannot support bitrate change +// ----------------------------------------------------------------------------- +// +void CMccSymStreamBase::DoChangeBitrateL( TInt /*aBitrate*/ ) + { + // This will be trapped inside ChangeBitrate() function + __SUBCONTROLLER( "CMccSymStreamBase::DoChangeBitrateL KErrNotSupported" ); + User::Leave( KErrNotSupported ); + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::BindContextIntoStreamL +// ----------------------------------------------------------------------------- +// +void CMccSymStreamBase::BindContextIntoStreamL( TUint32 /*aEndpointId*/, + const TMccCryptoContext& /*aContextParams*/ ) + { + + __SUBCONTROLLER( "CMccSymStreamBase::BindContextIntoStreamL KErrNotSupported" ); + User::Leave( KErrNotSupported ); + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::RemoveCryptoContext +// ----------------------------------------------------------------------------- +// +TInt CMccSymStreamBase::RemoveContext( TUint32 aEndpointId ) + { + if ( iDatasource && iDatasource->DataSourceType() == KMccRtpSourceUid && + ( aEndpointId == MCC_ENDPOINT_ID( iDatasource ) || 0 == aEndpointId ) ) + { + static_cast( iDatasource )->RemoveCryptoContext(); + } + + if ( iDatasink && iDatasink->DataSinkType() == KMccRtpSinkUid && + ( aEndpointId == MCC_ENDPOINT_ID( iDatasink ) || 0 == aEndpointId ) ) + { + static_cast( iDatasink )->RemoveCryptoContext(); + } + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::IsControlled +// ----------------------------------------------------------------------------- +// +TBool CMccSymStreamBase::IsControlled( TUint32 aEndpointId ) const + { + TBool controlled( EFalse ); + for ( TInt i = 0; i < iControlledEndpoints.Count() && !controlled; i++ ) + { + controlled = ( iControlledEndpoints[ i ] == aEndpointId ); + } + return controlled; + } + +// ----------------------------------------------------------------------------- +// CMccSymStreamBase::ClearStateChangeEvent +// ----------------------------------------------------------------------------- +// +void CMccSymStreamBase::ClearStateChangeEvent() + { + iStreamStateChangeEvent = TMccEvent(); + } + +// ========================== OTHER EXPORTED FUNCTIONS ========================= + +// End of File