--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/vtengines/videoteleng/Src/Media/CVtEngMediaHandler.cpp Mon Nov 23 14:47:47 2009 +0200
@@ -0,0 +1,4580 @@
+/*
+* Copyright (c) 2004-2007 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: Implementation of video session interface.
+*
+*/
+
+
+// INCLUDE FILES
+#include "CVtEngMediaHandler.h"
+#include "CVtEngLocalVideo.h"
+#include "CVtEngRemoteVideo.h"
+#include "MVtEngFrameObserver.h"
+#include "CVtEngStateManager.h"
+#include "CVtEngOperation.h"
+#include "TVtEngRendering.h"
+#include "TVtEngRenderingDSA.h"
+#include "TVtEngRenderingDP.h"
+#include "TVtEngRenderingNGA.h"
+#include "VtEngUtils.h"
+#include "CVtEngInitializer.h"
+#include "CVtEngEventManager.h"
+#include "CVtEngSettings.h"
+#include "CVtEngHandlerContainer.h"
+#include "MVtEngDtmfHandler.h"
+#include "cvtengmdtrcommandsender.h"
+#include "VtEngPanic.h"
+#include <sysutil.h>
+#include <cvtlogger.h>
+#include <mvtprotocolhandler.h>
+#include <e32des8.h>
+#include <videotelephonyvariant.hrh>
+#include <es_sock.h> // BigEndian
+
+#include <mvtengcamerapreferences.h>
+#include "cvtengrecord2file.h"
+
+// MACROS
+#ifdef VTDEBUG
+// In debug mode sinks and sources are not necessarily added.
+#define ADD_VIDEO_SINK { \
+ if ( DEBUG_CFG_NO_VIDEO_SINK == 0 ) { AddVideoSink(); } }
+#define ADD_VIDEO_SOURCE { \
+ if ( DEBUG_CFG_NO_VIDEO_SOURCE == 0 ) { AddVideoSource(); } }
+#define ADD_AUDIO_SOURCE \
+ { if ( DEBUG_CFG_NO_AUDIO_SOURCE == 0 ) { AddAudioSource(); } }
+#define ADD_AUDIO_SINK \
+ { if ( DEBUG_CFG_NO_AUDIO_SINK == 0 ) { AddAudioSink(); } }
+#else
+// In release mode they are added.
+#define ADD_VIDEO_SINK AddVideoSink();
+#define ADD_VIDEO_SOURCE AddVideoSource();
+#define ADD_AUDIO_SOURCE AddAudioSource();
+#define ADD_AUDIO_SINK AddAudioSink();
+#endif // VTDEBUG
+
+// CONSTANTS
+const TInt KVtEngOperationArraySize = 2;
+// System version string buffer length.
+const TInt KVtEngSwVersionTextLength = KSysUtilVersionTextLength;
+// Country code for version information.
+const TUint8 KVtEngCountryCodeForProto = 60;
+// Extension code for version information (unknown).
+const TUint8 KVtEngExtensionForProto = 0;
+// Manufacturer code for version information (unknown).
+const TUint32 KVtEngManufacturerForProto = 0;
+// Timer to detect too long disconnect.
+const TInt KVtEngDisconnectionTimer = 20000000;
+// Space character constant.
+const TText KVtEngCharacterSpace( ' ' );
+// New line (\n) character constant.
+const TInt KVtEngCharacterEndLine( 10 );
+
+// Multiplex delay in milliseconds
+const TInt KVtEngMultiplexingDelay = 150;
+
+// TradeOff values
+const TInt KVtEngTradeOffDetailMax = 9;
+const TInt KVtEngTradeOffNormalMax = 19;
+const TInt KVtEngTradeOffMotionMax = 31;
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::CVtEngMediaHandler
+// C++ constructor can NOT contain any code, that
+// might leave.
+// -----------------------------------------------------------------------------
+//
+CVtEngMediaHandler::CVtEngMediaHandler() :
+ iProtoState( MVtProtocolCommand::EIdle ),
+ iAudioCtrl(0),
+ iProtoMaxVolume(0),
+ iTempProviderInfo( CVtEngLocalVideo::KVtEngProviderNone ),
+ iH324Config( 0 ),
+ iH263Encoder( 0 )
+ {
+ if ( CVtEngUtility::Settings().IsDefaultStillImageDefined() )
+ {
+ iTempProviderInfo = CVtEngLocalVideo::KVtEngProviderDefaultStillImage;
+ }
+
+ // Check is AMR-WB supported or not in platform. Adjusted using local
+ // variation.
+ if ( CVtEngUtility::Settings().CheckBits( KVTLVFlagEnableAMR_WB ) )
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_CONSTRUCT, "MH.c++ AMR-WB set ON" )
+ iSdkInitInfo.iAMRWBOn = ETrue;
+ }
+ else
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_CONSTRUCT, "MH.c++ AMR-WB set OFF" )
+ iSdkInitInfo.iAMRWBOn = EFalse;
+ }
+
+ if ( CVtEngUtility::Settings().CheckBits( KVTLVFlagDisableMpeg4 ) )
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_CONSTRUCT, "MH.c++ Mpeg4 set OFF" )
+ iSdkInitInfo.iDisableMpeg4 = ETrue;
+ }
+ else
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_CONSTRUCT, "MH.c++ Mpeg4 set ON" )
+ iSdkInitInfo.iDisableMpeg4 = EFalse;
+ }
+
+ __VTPRINT( DEBUG_MEDIA | DEBUG_CONSTRUCT, "MH.c++" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::ConstructL
+// Symbian 2nd phase constructor can leave.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::ConstructL()
+ {
+ __VTPRINTENTER( "MH.ConstructL" )
+
+ iAsyncCallback = CIdle::NewL( CActive::EPriorityHigh );
+ iPendingOps = new ( ELeave)
+ CArrayFixFlat<TCmdOpPair>( KVtEngOperationArraySize );
+ iPendingOps->SetReserveL( KVtEngOperationArraySize );
+
+ __VTPRINT2( DEBUG_MEDIA, "DebugFlags used are %d", CVtLogger::Flags() )
+
+ iLocalVideo = CVtEngLocalVideo::NewL( *this );
+ __VTPRINTEXIT( "MH.ConstructL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::NewL
+// Two-phased constructor.
+// -----------------------------------------------------------------------------
+//
+CVtEngMediaHandler* CVtEngMediaHandler::NewL()
+ {
+ CVtEngMediaHandler* self = new( ELeave )CVtEngMediaHandler();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop();
+ return self;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::~CVtEngMediaHandler
+// Destructor. Cannot leave.
+// -----------------------------------------------------------------------------
+//
+CVtEngMediaHandler::~CVtEngMediaHandler()
+ {
+ __VTPRINTENTER( "MH.~" )
+ if ( iPendingOps )
+ {
+ iPendingOps->Reset(); // Make sure this is empty
+ delete iPendingOps;
+ }
+ delete iPendingOp;
+ delete iTimer;
+ delete iAsyncCallback;
+ delete iLocalVideo;
+ delete iRemoteVideo;
+ __VTPRINTEXIT( "MH.~" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::GetMediaState
+// Returns media state.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::GetMediaState(
+ const TMediaDirection aMediaDirection,
+ TInt& aActiveMedia ) const
+ {
+ __VTPRINT2( DEBUG_MEDIA, "MH.GetMediaState direction=%d", aMediaDirection )
+ aActiveMedia = 0;
+ switch ( aMediaDirection )
+ {
+ case EMediaOutgoing:
+ {
+ const TInt result( iLocalVideo->GetMediaState( aActiveMedia ) );
+ if ( !IsFlag( EOutVideoChannelClosed ) )
+ {
+ aActiveMedia |= EMediaVideoChannelOpen;
+ }
+ if ( !IsFlag( EOutAudioChannelClosed ) )
+ {
+ aActiveMedia |= EMediaAudioChannelOpen;
+ }
+ return result;
+ }
+
+ case EMediaIncoming:
+ aActiveMedia = iRemoteMediaState;
+ if ( ( iRemoteVideo && !iRemoteVideo->GetDsaState() ) )
+ {
+ aActiveMedia &= (~EMediaVideo);
+ }
+ __VTPRINT2( DEBUG_MEDIA, "MH.remoteState=%d", aActiveMedia )
+ return KErrNone;
+
+ default:
+ break;
+ }
+ return KErrNotSupported;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::RenderingStarted
+// Returns the state of video.
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngMediaHandler::RenderingStarted(
+ const TMediaDirection aDirection ) const
+ {
+ __VTPRINT2( DEBUG_MEDIA, "MH.RS %d", aDirection )
+ TBool started( EFalse );
+ if( aDirection == EMediaOutgoing )
+ {
+ started = iLocalVideo->ViewFinderStarted();
+ }
+ else // EMediaIncoming
+ {
+ started = iRemoteVideo->GetDsaState();
+ }
+
+ __VTPRINT2( DEBUG_MEDIA, "MH.RS started %d", started )
+ return started;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::GetSource
+// Returns active source.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::GetSource( TMediaSource& aSource ) const
+ {
+ TInt err( KErrNotReady );
+ if ( iLocalVideo )
+ {
+ aSource = iLocalVideo->GetMediaSource();
+ err = KErrNone;
+ }
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::GetSourcesCaps
+// Returns source selection capabilities.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::GetSourcesCaps( TInt& aCaps ) const
+ {
+ TInt err( KErrNotReady );
+ if ( iLocalVideo )
+ {
+ err = iLocalVideo->GetSourceCaps( aCaps );
+ }
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::GetCurrentCameraId
+// Returns current camera.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::GetCurrentCameraId( TCameraId& aId ) const
+ {
+ __VTPRINT( DEBUG_GEN, "MH.GetCurrentCameraId")
+ aId = iSelectedCameraId;
+ TInt err( KErrNotReady );
+
+ TBool initialized( EFalse );
+ err = iLocalVideo->IsInitialized( aId, initialized );
+ if ( !initialized && ( err != KErrInUse ) )
+ {
+ __VTPRINT2( DEBUG_GEN, "MH.GetCurrentCameraId err=%d", KErrNotReady )
+ return KErrNotReady;
+ }
+ __VTPRINT2( DEBUG_GEN, "MH.GetCurrentCameraId initialized err=%d", err )
+ return err;//Not initialized
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::GetCameraInfo
+// Returns camera information.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::GetCameraInfo(
+ const TCameraId aId, TCameraInfo& aInfo ) const
+ {
+ return iLocalVideo->GetCameraInfo( aId, aInfo );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::GetCurrentZoomStep
+// Returns current zooming.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::GetCurrentZoomStep( TInt& aCurrentStep )
+ {
+ return iLocalVideo->GetDigitalZoomFactor( aCurrentStep );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::GetMaxZoomStep
+// Returns maximum zooming.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::GetMaxZoomStep( TInt& aMaxZoomStep )
+ {
+ return iLocalVideo->GetMaxDigitalZoomStep( aMaxZoomStep );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::GetMajorZoomStepCount
+// Gets number of major zoom level leaps.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::GetMajorZoomStepCount( TInt& aCount )
+ {
+ return iLocalVideo->GetMajorDigitalZoomStepCount( aCount );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::GetMajorZoomStep
+// Maps major zoom leap step to corresponding step index.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::GetMajorZoomStep( TInt aIndex, TInt& aStep )
+ {
+ if ( iLocalVideo )
+ {
+ iLocalVideo->GetMajorDigitalZoomStep( aIndex, aStep );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::GetFreezeSupported
+// Maps major zoom leap step to corresponding step index.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::GetFreezeSupported( TBool& aFreezeSupported) const
+ {
+ if ( iLocalVideo )
+ {
+ return iLocalVideo->GetFreezeSupported( aFreezeSupported );
+ }
+ return KErrNotReady;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::GetFreezeState
+// Returns KErrNotReady if provider is not ready yet. If KErrNone is returned
+// then aFrozen will be ETrue if the provider is frozen, EFalse otherwise.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::GetFreezeState( TBool& aFrozen ) const
+ {
+ if ( iLocalVideo )
+ {
+ aFrozen = iLocalVideo->IsFrozen();
+ return KErrNone;
+ }
+ return KErrNotReady;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::GetDsaState
+// Returns media state.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::GetDsaState(
+ const TMediaDirection aMediaDirection,
+ TBool& aActive ) const
+ {
+ if ( !iRemoteVideo )
+ {
+ return KErrNotReady;
+ }
+ switch ( aMediaDirection )
+ {
+ case EMediaOutgoing:
+ break;
+ case EMediaIncoming:
+ aActive = iRemoteVideo->GetDsaState();
+ return KErrNone;
+ default:
+ break;
+ }
+ return KErrNotSupported;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::VideoCallConnected
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngMediaHandler::VideoCallConnected () const
+ {
+ TBool connected = EFalse;
+ if ( MVtProtocolCommand::EConnected == iProtoState )
+ {
+ connected = ETrue;
+ }
+ return connected;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::GetVideoQuality
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::GetVideoQuality( TVideoQuality& aVideoQuality ) const
+ {
+ __VTPRINTENTER( "MH.GetVideoQuality" )
+ aVideoQuality = iVideoQuality.VideoQuality();
+ __VTPRINTEXIT( "MH.GetVideoQuality" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::GetObjectSharingState
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::GetObjectSharingState(
+ TShareObjectState& aObjectSharingState ) const
+ {
+ __VTPRINTENTER( "MH.GetObjectSharingState" )
+ if( iProtoState == MVtProtocolCommand::EConnected )
+ {
+ iLocalVideo->GetObjectSharingState( aObjectSharingState );
+ }
+ else
+ {
+ aObjectSharingState = ENotAbleToShare;
+ }
+ __VTPRINTEXIT( "MH.GetObjectSharingState" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::GetCameraOrientations
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::GetCameraOrientations(
+ TCameraOrientation& aPrimaryCameraOrientation,
+ TCameraOrientation& aSecondaryCameraOrientation ) const
+ {
+ __VTPRINTENTER( "MH.GetCameraOrientations" )
+ CVtEngSettings& settings = CVtEngUtility::Settings();
+ settings.GetCameraOrientations( aPrimaryCameraOrientation,
+ aSecondaryCameraOrientation );
+ __VTPRINTEXIT( "MH.GetCameraOrientations" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::RequestLastRemoteFrame
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::RequestLastRemoteFrame( )
+ {
+ __VTPRINTENTER( "MH.RequestLastRemoteFrame" )
+ if( iRemoteVideo )
+ iRemoteVideo->RequestLastFrame();
+ __VTPRINTEXIT( "MH.RequestLastRemoteFrame" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::ValidateCommand
+// Checks if command is valid in current proto state.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::ValidateCommand( const TVtEngCommandId aCommand ) const
+ {
+ __VTPRINTENTER( "MH.ValidateCommand" )
+ __VTPRINT2( DEBUG_MEDIA, "MH.ValidateCommand cmd=%d", aCommand )
+ TInt okToPerform( KErrNotReady );
+ if ( iInitialized )
+ {
+ switch ( aCommand )
+ {
+ case KVtEngMuteOutgoingAudio:
+ case KVtEngUnmuteOutgoingAudio:
+ // mute/unmute not possible if audio channel closed.
+ if ( IsFlag( EOutAudioChannelClosed ) ) {
+ break;
+ }
+ case KVtEngSetAudioRouting:
+ case KVtEngSetAudioVolume:
+ if ( ( iProtoState == MVtProtocolCommand::EConnected ) && !iPendingOp )
+ {
+ okToPerform = KErrNone;
+ }
+ break;
+ case KVtEngIncreaseAudioVolume:
+ case KVtEngDecreaseAudioVolume:
+
+ if ( iProtoState == MVtProtocolCommand::EConnected )
+ {
+ okToPerform = KErrNone;
+ }
+ break;
+ case KVtEngRequestLastRemoteFrame:
+ if ( iProtoState == MVtProtocolCommand::EConnected )
+ {
+ okToPerform = KErrNone;
+ }
+ break;
+ case KVtEngPrepareViewFinder:
+ case KVtEngPrepareViewFinderDSA:
+ case KVtEngPrepareRemoteRenderDSA:
+ case KVtEngPrepareViewFinderDP:
+ case KVtEngPrepareRemoteRenderDP:
+ case KVtEngPrepareRemoteRenderNGA:
+ okToPerform = KErrNone; // can be done any time
+ break;
+
+ case KVtEngHandleLayoutChange:
+ if ( iLocalVideo && iLocalVideo->ActiveProvider() !=
+ CVtEngLocalVideo::KVtEngProviderNone && !iPendingOp )
+ {
+ okToPerform = KErrNone;
+ }
+ break;
+
+ case KVtEngSetZoomStep:
+ {
+ const CVtEngLocalVideo::TVtEngProviderType
+ activeProvider( iLocalVideo->ActiveProvider() );
+ if ( iRequestStatus == NULL &&
+ iVSInitState == EInitStateNone &&
+ ( activeProvider == CVtEngLocalVideo::KVtEngProviderCam1 ||
+ activeProvider == CVtEngLocalVideo::KVtEngProviderCam2 ) )
+ {
+ okToPerform = KErrNone;
+ }
+ }
+ break;
+ case KVtEngSetSource:
+ if ( !IsFlag( EOutVideoChannelClosed ) )
+ {
+ okToPerform = KErrNone;
+ }
+ // when EOutVideoChannelClosed is active
+ // don't allow source switch because it may require
+ // pause or resume on Protocol which would fail when video
+ // channel is closed.
+ // Note1: this is especially for the case when channel is
+ // closed after being already open.
+ // Note2: it must be possible to set source already before Protocol
+ // is connected (in MONA calls) so Proto state check is not done.
+ break;
+ case KVtEngPrepareCamera:
+ case KVtEngStartViewFinder:
+ case KVtEngFreeze:
+ case KVtEngUnfreeze:
+ if ( iRequestStatus == NULL &&
+ // If initialising or change provider during reset then
+ // not allowed
+ iVSInitState == EInitStateNone &&
+ // If terminate ongoing then not allowed
+ iProtoState != MVtProtocolCommand::EIdle )
+ {
+ okToPerform = KErrNone;
+ if( aCommand == KVtEngFreeze )
+ {
+ if( !iLocalVideo->OkToFreeze() )
+ {
+ okToPerform = KErrNotReady;
+ }
+ }
+ else if( aCommand == KVtEngUnfreeze )
+ {
+ if( !iLocalVideo->OkToUnfreeze() )
+ {
+ okToPerform = KErrNotReady;
+ }
+ }
+ }
+ break;
+ case KVtEngSetVideoQuality:
+ if( IsPending( ESetVideoQuality ) != KErrNotFound )
+ {
+ okToPerform = KErrNotReady;
+ }
+ else
+ {
+ if ( iRequestStatus == NULL && iProtoState != MVtProtocolCommand::EIdle )
+ {
+ okToPerform = KErrNone;
+ }
+ }
+ break;
+
+ case KVtEngInitializeShareImage:
+ {
+ TShareObjectState objectSharingState;
+ GetObjectSharingState( objectSharingState );
+ if ( ( objectSharingState != ENotAbleToShare ) &&
+ ( objectSharingState != EInitializingShareImage ) &&
+ !IsFlag( EOutVideoChannelClosed ) )
+ {
+ okToPerform = KErrNone;
+ }
+ }
+ break;
+
+ case KVtEngStartShareImage:
+ {
+ TShareObjectState objectSharingState;
+ GetObjectSharingState( objectSharingState );
+ if( objectSharingState != ENotAbleToShare )
+ {
+ okToPerform = KErrNone;
+ }
+ }
+ break;
+
+ case KVtEngStopShareImage:
+ {
+ TShareObjectState objectSharingState;
+ GetObjectSharingState( objectSharingState );
+ if ( ( objectSharingState == ESharingImage ) &&
+ !IsFlag( EOutVideoChannelClosed ) )
+ {
+ okToPerform = KErrNone;
+ }
+ }
+ break;
+
+ case KVtEngTerminateSession:
+ if ( iProtoState == MVtProtocolCommand::EConnected ||
+ iProtoState == MVtProtocolCommand::EConnecting )
+ {
+ okToPerform = KErrNone;
+ }
+ break;
+
+ default:
+ okToPerform= KErrNotSupported;
+ break;
+ }
+ }
+ __VTPRINT2( DEBUG_MEDIA, "MH.ValidateCommand okToPerform=%d", okToPerform )
+ __VTPRINTEXIT( "MH.ValidateCommand" )
+ return okToPerform;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::IsVideoChannelClosed
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngMediaHandler::IsVideoChannelClosed() const
+ {
+ __VTPRINTENTER( "MH.IsVideoChannelClosed" )
+ const TBool result( IsFlag( EOutVideoChannelClosed ) );
+ __VTPRINTEXITR( "MH.IsVideoChannelClosed %d", result )
+ return result;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::HandleL
+// Handles a request.
+//
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::HandleL( CVtEngOperation& aOperation )
+ {
+ __VTPRINTENTER( "MH.HandleL" )
+
+ const TVtEngCommandId id( aOperation.Command() );
+ if ( !iInitialized )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.Handle not ready" )
+ User::Leave( KErrNotReady );
+ }
+ __VTPRINT2( DEBUG_MEDIA, "MH.Handle cmdId=%d", id )
+ switch ( id )
+ {
+ case KVtEngSetUIForeground:
+ TBool foregroundValue;
+ TVtEngOpParamUtil<TBool>::Set( foregroundValue, aOperation );
+ if( iLocalVideo )
+ {
+ iLocalVideo->SetUIForeground( foregroundValue );
+ }
+ if( iRemoteVideo )
+ {
+ iRemoteVideo->SetUIForegroundL( foregroundValue );
+ }
+ break;
+
+ case KVtEngSetAudioVolume:
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.Handle.Vol" )
+ MVtEngAudio::TVtEngOutputVolume volSetting;
+ TVtEngOpParamUtil<MVtEngAudio::TVtEngOutputVolume>::Set(
+ volSetting, aOperation );
+
+ // Store volume.
+ CVtEngSettings& settings = CVtEngUtility::Settings();
+ settings.SetVolume(
+ volSetting.iHandsetVolume,
+ volSetting.iHandsfreeVolume,
+ ETrue );
+ settings.SetVolume(
+ volSetting.iHandsetVolume,
+ volSetting.iHandsfreeVolume,
+ EFalse );
+
+ // Update volume.
+ iPendingVolumeOp = &aOperation;
+ AssignPendingOp( aOperation );
+ UpdateVolume();
+
+ if ( IsPending( ESetAudioVolume ) == KErrNotFound )
+ {
+ // No volume operation ongoing. Need to complete operation by itself.
+ AsyncCompleteOp();
+ }
+ }
+ break;
+
+ case KVtEngIncreaseAudioVolume:
+ {
+ CVtEngAudioHandler& audioHandler(
+ static_cast< CVtEngAudioHandler& >(
+ CVtEngUtility::StateManager()->Handlers().Audio() ) );
+ if ( audioHandler.IncreaseVolume() )
+ {
+ UpdateVolume();
+ }
+ }
+ break;
+
+ case KVtEngDecreaseAudioVolume:
+ {
+ CVtEngAudioHandler& audioHandler(
+ static_cast< CVtEngAudioHandler& >(
+ CVtEngUtility::StateManager()->Handlers().Audio() ) );
+ if ( audioHandler.DecreaseVolume() )
+ {
+ UpdateVolume();
+ }
+ }
+ break;
+
+ case KVtEngMuteOutgoingAudio:
+ {
+ // No Local video if not on target
+#if !defined( __WINS__ )
+ AddOperation( EMuteAudio,
+ iSessionCommand->PauseAudioL( *iLocalVideo->AudioSource()) );
+#endif // !WINS
+ AssignPendingOp( aOperation );
+ }
+ break;
+ case KVtEngUnmuteOutgoingAudio:
+ {
+ // No Local video if not on target
+#if !defined( __WINS__ )
+ AddOperation ( EUnmuteAudio,
+ iSessionCommand->ResumeAudioL( *iLocalVideo->AudioSource() ) );
+#endif // !WINS
+ AssignPendingOp( aOperation );
+ }
+ break;
+ case KVtEngPrepareViewFinder:
+ {
+ const TPckgC<TVtEngRenderingOptions>& pckg =
+ static_cast< const TPckgC<TVtEngRenderingOptions>& >
+ ( *aOperation.Parameters() );
+ const TVtEngRenderingOptions& options = pckg();
+ iLocalVideo->SetViewFinderParameters( options );
+ }
+ break;
+ case KVtEngPrepareRemoteRenderNGA:
+ {
+ const TPckgC<TVtEngRenderingOptionsNGA>& pckg =
+ static_cast< const TPckgC<TVtEngRenderingOptionsNGA>& >
+ ( *aOperation.Parameters() );
+ const TVtEngRenderingOptionsNGA& options = pckg();
+ iRemoteVideo->SetRenderingParametersL( options );
+ }
+ break;
+ case KVtEngPrepareViewFinderDSA:
+ case KVtEngPrepareRemoteRenderDSA:
+ {
+ const TPckgC<TVtEngRenderingOptionsDSA>& pckg =
+ static_cast< const TPckgC<TVtEngRenderingOptionsDSA>& >
+ ( *aOperation.Parameters() );
+ const TVtEngRenderingOptionsDSA& options = pckg();
+ if ( id == KVtEngPrepareViewFinderDSA )
+ {
+ iLocalVideo->SetViewFinderParameters( options );
+ }
+ else if ( iRemoteVideo )
+ {
+ iRemoteVideo->SetRenderingParametersL( options );
+ }
+ }
+ break;
+
+ case KVtEngPrepareViewFinderDP:
+ case KVtEngPrepareRemoteRenderDP:
+ {
+ const TPckgC<TVtEngRenderingOptionsDP>& pckg =
+ static_cast< const TPckgC<TVtEngRenderingOptionsDP>& >
+ ( *aOperation.Parameters() );
+ const TVtEngRenderingOptionsDP& options = pckg();
+ if ( id == KVtEngPrepareViewFinderDP )
+ {
+ iLocalVideo->SetViewFinderParameters( options );
+ }
+ else if ( iRemoteVideo )
+ {
+ iRemoteVideo->SetRenderingParametersL( options );
+ }
+ }
+ break;
+
+ case KVtEngHandleLayoutChange:
+ iLocalVideo->HandleLayoutChangeL();
+ AssignPendingOp( aOperation );
+ break;
+
+ case KVtEngSetSource:
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.set source" )
+ MVtEngMedia::TMediaSource source;
+ TVtEngOpParamUtil<MVtEngMedia::TMediaSource>::Set( source,
+ aOperation );
+
+ iLocalVideo->InitializeOnly( EFalse );
+ TOperation startedOp( ENone );
+ switch ( source )
+ {
+ case EMediaCamera:
+ __VTPRINT( DEBUG_MEDIA, "EMediaCamera" )
+ iTempProviderInfo =
+ ( iSelectedCameraId == ESecondaryCamera ) ?
+ CVtEngLocalVideo::KVtEngProviderCam2 :
+ CVtEngLocalVideo::KVtEngProviderCam1;
+
+ SetFlag( EProtoContVideoBlankProv );
+ startedOp = EnableVideoL( ETrue );
+ if ( startedOp == ENone )
+ {
+ // Did nothing
+ ClearFlag( EProtoContVideoBlankProv );
+ }
+ iLocalVideo->ResumeVideoSending();
+ break;
+ case EMediaCameraPri:
+ __VTPRINT( DEBUG_MEDIA, "EMediaCameraPri" )
+ iTempProviderInfo = CVtEngLocalVideo::KVtEngProviderCam1;
+ iSelectedCameraId = EPrimaryCamera;
+ ClearFlag( EProtoContVideoBlankProv );
+ break;
+ case EMediaCameraSec:
+ __VTPRINT( DEBUG_MEDIA, "EMediaCameraSec" )
+ iTempProviderInfo = CVtEngLocalVideo::KVtEngProviderCam2;
+ iSelectedCameraId = ESecondaryCamera;
+ ClearFlag( EProtoContVideoBlankProv );
+ break;
+ case EMediaStillImage:
+ __VTPRINT( DEBUG_MEDIA, "EMediaStillImage" )
+ iTempProviderInfo = CVtEngLocalVideo::KVtEngProviderImage;
+ SetFlag( EProtoContVideoBlankProv );
+ startedOp = EnableVideoL( ETrue );
+ if ( startedOp == ENone )
+ {
+ // Did nothing
+ ClearFlag( EProtoContVideoBlankProv );
+ }
+ break;
+ case EMediaNone:
+ __VTPRINT( DEBUG_MEDIA | DEBUG_RETURN, "EMediaNone" )
+ if ( CVtEngUtility::Settings().
+ IsDefaultStillImageDefined() )
+ {
+ iTempProviderInfo =
+ CVtEngLocalVideo::KVtEngProviderDefaultStillImage;
+
+ SetFlag( EProtoContVideoBlankProv );
+ startedOp = EnableVideoL( ETrue );
+ if ( startedOp == ENone )
+ {
+ // Did nothing
+ ClearFlag( EProtoContVideoBlankProv );
+ }
+ }
+ else
+ {
+ iTempProviderInfo =
+ CVtEngLocalVideo::KVtEngProviderNone;
+
+ ClearFlag( EProtoContVideoBlankProv );
+ SetFlag( EProtoPauseVideoBlankProv );
+ if ( !IsFlag(
+ EProtoVideoSourceAdded ) && iProtoState != MVtProtocolCommand::EConnected )
+ {
+ // Set as not enabled video when no sources
+ __VTPRINT( DEBUG_MEDIA, "MH.set blanked - not ready" )
+ EnableVideoL( EFalse );
+ }
+ else
+ {
+ // we have "done" something
+ startedOp = EDisableVideo;
+ iLocalVideo->PauseVideoSending();
+ }
+ }
+ break;
+ default:
+ __VTPRINT( DEBUG_MEDIA, "invalid source" )
+ User::Leave( KErrArgument );
+ }
+ TBool selectOngoing( EFalse );
+ ClearFlag( ESourceUpdateNeeded );
+ TInt err( KErrNone );
+
+ // Either pausing or switching between still and camera
+ if ( !IsFlag( EProtoContVideoBlankProv ) )
+ {
+ TRAP( err, selectOngoing =
+ iLocalVideo->SelectSourceL( iTempProviderInfo ) );
+ __VTPRINT3( DEBUG_MEDIA, " ongoing=%d, op=%d",selectOngoing,
+ startedOp )
+ }
+
+ if ( ( selectOngoing || IsFlag( EProtoContVideoBlankProv ) ||
+ IsFlag( EProtoContVideoBlankInit ) ) &&
+ startedOp != ENone && err == KErrNone )
+ {
+ // Enabling/disabling video started. Set flag that operation
+ // should be completed only when both callback from Protocol and
+ // local video (switch done) are complete.
+ __VTPRINT( DEBUG_MEDIA, "MH.set source 2stage" )
+ SetFlag( ETwoStageOperation );
+ }
+ else
+ {
+ User::LeaveIfError( err );
+ }
+ AssignPendingOp( aOperation );
+ }
+ break;
+ case KVtEngPrepareCamera:
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.prepare cam" )
+ MVtEngMedia::TPrepareCameraParams params;
+ if ( aOperation.Parameters() )
+ {
+ TVtEngOpParamUtil< MVtEngMedia::TPrepareCameraParams >
+ ::Set( params, aOperation );
+ }
+ else
+ {
+ params.iMediaSource = EMediaCamera;
+ params.iInitialize = ETrue;
+ }
+ CVtEngLocalVideo::TVtEngProviderType
+ type( CVtEngLocalVideo::KVtEngProviderCam1 );
+ switch ( params.iMediaSource )
+ {
+ case EMediaCamera:
+ type = ( iSelectedCameraId == ESecondaryCamera ) ?
+ CVtEngLocalVideo::KVtEngProviderCam2 :
+ CVtEngLocalVideo::KVtEngProviderCam1;
+ break;
+ case EMediaCameraPri:
+ iSelectedCameraId = EPrimaryCamera;
+ type = CVtEngLocalVideo::KVtEngProviderCam1;
+ break;
+ case EMediaCameraSec:
+ iSelectedCameraId = ESecondaryCamera;
+ type = CVtEngLocalVideo::KVtEngProviderCam2;
+ break;
+ default:
+ User::Leave( KErrArgument );
+ break;
+ }
+ iLocalVideo->SetIsPrepareCameraCalled( ETrue );
+ AssignPendingOp( aOperation );
+ if ( params.iInitialize )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.prepare cam iInitialize TRUE" )
+ iLocalVideo->InitializeOnly();
+ ClearFlag( ESourceUpdateNeeded );
+ iLocalVideo->SelectSourceL( type );
+ }
+ else
+ {
+ __VTPRINT( DEBUG_MEDIA,
+ "MH.prepare cam iInitialize FALSE, complete with KErrNone" )
+ AsyncCompleteOp( KErrNone );
+ }
+ }
+ break;
+
+ case KVtEngSetZoomStep:
+ {
+ TInt zoom( 0 );
+ TVtEngOpParamUtil<TInt>::Set( zoom, aOperation );
+ iLocalVideo->SetDigitalZoomFactorL( zoom );
+ }
+ break;
+
+ case KVtEngFreeze:
+ iLocalVideo->FreezeL();
+ break;
+
+ case KVtEngUnfreeze:
+ iLocalVideo->UnfreezeL();
+ AssignPendingOp( aOperation );
+ break;
+
+ case KVtEngStartViewFinder:
+ iLocalVideo->StartViewFinderL( ETrue );
+ break;
+ case KVtEngStopViewFinder:
+ iLocalVideo->StopViewFinder( ETrue );
+ break;
+ case KVtEngStartRenderRemote:
+ iRemoteVideo->StartVideoL();
+ break;
+ case KVtEngStopRenderRemote:
+ iRemoteVideo->StopVideoRendering();
+ break;
+ case KVtEngPauseRenderRemote:
+ iRemoteVideo->PauseVideoL();
+ break;
+ case KVtEngRequestLastRemoteFrame:
+ RequestLastRemoteFrame();
+ break;
+ case KVtEngTerminateSession:
+ AssignPendingOp( aOperation );
+ break;
+
+ // Set video quality
+ case KVtEngSetVideoQuality:
+ {
+ TVideoQuality videoQuality( EVideoQualityUndefined );
+ TVtEngOpParamUtil< TVideoQuality >::Set( videoQuality, aOperation );
+ SetPeerVideoQuality( videoQuality );
+ }
+ break;
+
+ // Initialize share
+ case KVtEngInitializeShareImage:
+ {
+ TShareObjectImageParameters parameters;
+ TVtEngOpParamUtil< TShareObjectImageParameters >::Set(
+ parameters, aOperation );
+ TBool firstTime = EFalse;
+ iLocalVideo->InitializeShareImageL( parameters, firstTime );
+ AssignPendingOp( aOperation );
+ if ( firstTime )
+ {
+ iVideoAction = IsFlag( EProtoVideoTrackPaused ) ?
+ EVideoActionEnable : EVideoActionNone;
+ }
+ }
+ break;
+
+ // Start share
+ case KVtEngStartShareImage:
+ iLocalVideo->StartShareImageL();
+ AssignPendingOp( aOperation );
+ break;
+
+ // Stop Image sharing
+ case KVtEngStopShareImage:
+ {
+ // If video sending needs to be paused when sharing is stopped
+ // then do it before doing the actual provider switch. It is
+ // done before hand to prevent dummy frame sending to receiving
+ // end (ie. black frame).
+ const TBool needsPause( iLocalVideo->ShareStoredSource() ==
+ CVtEngLocalVideo::KVtEngProviderNone );
+ if ( needsPause )
+ {
+ // With this flag we prevent premature operation
+ // complete after the pause command has been executed.
+ iPauseNoCompleteOp = ETrue;
+ EnableVideoL( EFalse );
+ }
+ // reset the action flag.
+ iVideoAction = EVideoActionNone;
+ iLocalVideo->StopShareImageL();
+ AssignPendingOp( aOperation );
+ }
+ break;
+
+ default:
+ User::Leave( KErrNotSupported );
+ break;
+ }
+ __VTPRINTEXIT( "MH.HandleL" )
+ }
+
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::HandleSessionCommandEventL
+// Handles command completion in protocol engine.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::HandleSessionCommandEventL(
+ const TVtCommandResponse& aResponse )
+ {
+ __VTPRINTENTER( "MH.HandleSessionCommandEventL" )
+ const TVtCommandType type( aResponse.iCmdType );
+ if ( type == EVtCommandGetSDKInfo )
+ {
+ // ignore completely
+ __VTPRINTEXIT( "MH.HandleSessionCommandEventL" )
+ return;
+ }
+ const TInt protoCmdId( aResponse.iCmdId );
+ const TInt protoResponse( aResponse.iCmdStatus );
+ TInt event( KVtEngEventNone );
+ __VTPRINT2( DEBUG_MEDIA, "MH.protoComC type=%d", type )
+ __VTPRINT3( DEBUG_MEDIA, "MH.protoComC cmdId=%d,response=%d", protoCmdId, protoResponse )
+
+ CVtEngStateManager* states = CVtEngUtility::StateManager();
+ switch ( type )
+ {
+ case EVtCommandGetProtocolState:
+ break;
+ case EVtCommandInit://PVT_COMMAND_INIT -> ESetup
+ {
+ CVtEngUtility* utils = CVtEngUtility::EngineUtils();
+ iSessionCommand = utils->Initializer().GetSessionCommand();
+ iRemoteVideo = CVtEngRemoteVideo::NewL( *iSessionCommand, *states );
+ iInitialized = ETrue;
+ iProtoState = MVtProtocolCommand::ESetup;
+ __VTPRINT( DEBUG_MEDIA, "MH.protoComC: ESetup" )
+ states->Update();
+
+ // Get interfaces towards H324 and video encoder
+ QueryProtoInterfacesL();
+ }
+ break;
+ case EVtCommandGetProtocolInterface:
+ {
+ __VTPRINT2( DEBUG_MEDIA, "MH.protoComC:IF response=%d", protoCmdId )
+ if ( protoResponse == KErrNone &&
+ ( iProtoState == MVtProtocolCommand::ESetup ||
+ iProtoState == MVtProtocolCommand::EInitializing || // Allowed to query when initializing also
+ iProtoState == MVtProtocolCommand::EConnecting ||
+ iProtoState == MVtProtocolCommand::EConnected ) )
+ {
+ __ASSERT_DEBUG(
+ IsPending( EGet324CtrlInterface ) != KErrNotFound
+ || IsPending( EGetH263EncInterface ) != KErrNotFound,
+ Panic( EVtEngPanicMediaHandlerOpStateFailure ) );
+
+ //Check which interface.
+ if ( MatchResponseToPendingOps(
+ protoCmdId, EGet324CtrlInterface ) && iH324Config )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.protoComC:324 IF" )
+ iH324Config->SetObserverL ( this );
+
+ // Create DTMF handler with H324 interface.
+ CVtEngUtility* utils = CVtEngUtility::EngineUtils();
+ TRAP_IGNORE( utils->Initializer().CreateDtmfHandlerL( iH324Config ) );
+
+ // Set version to protocol -- cannot cause problem
+#ifdef VTDEBUG
+ TRAPD( err, SetVersionInfoL() );
+ if ( err != KErrNone )
+ {
+ __VTPRINT2( DEBUG_MEDIA,
+ "MH.protoComC:324 IF VersionInfo failed=%d", err )
+ }
+#else
+ TRAP_IGNORE( SetVersionInfoL() );
+#endif
+ // Set resolutions to Proto.
+ SetSupportedResolutions();
+
+ // Set Fast options
+ SetFastCsupOptions();
+
+ SetFlag( EProto324IFAcquired );
+ RemoveOperation( protoCmdId );
+ states->Update();
+ }
+ else if ( MatchResponseToPendingOps(
+ protoCmdId, EGetH263EncInterface ) )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.protoComC:IF 263 created" )
+ iH263Encoder->SetObserverL( this );
+ RemoveOperation( protoCmdId );
+ }
+ else
+ {
+ // Not supported interface.
+ __VTPRINT( DEBUG_MEDIA, "MH.protoComC:NOT requested" )
+ }
+ }
+ else
+ {
+ // failed or not in appropriate state
+ __VTPRINT( DEBUG_MEDIA, "MH.protoComC:query IF fail/incorrect state" )
+ RemoveOperation( protoCmdId );
+ }
+ }
+ break;
+
+ case EVtCommandResume:
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "MH.protoComC Resume" )
+
+ __ASSERT_DEBUG(
+ IsPending( EUnmuteAudio ) != KErrNotFound ||
+ IsPending( EEnableVideo ) != KErrNotFound ||
+ IsPending( EEnableVideoInternal ) != KErrNotFound,
+ Panic( EVtEngPanicMediaHandlerOpStateFailure ) );
+
+ // Was command unmute audio?
+ const TBool audioEnabled(
+ MatchResponseToPendingOps( protoCmdId, EUnmuteAudio ) );
+
+ if ( protoResponse == KErrNone )
+ {
+ if ( audioEnabled )
+ {
+ iLocalVideo->UnMute();
+ event = KVtEngAudioUnmuted;
+ }
+ else
+ {
+ iLocalVideo->ResumeVideoSending();
+ }
+ }
+
+ // Was command enable video?
+ const TBool videoEnabledByUser(
+ MatchResponseToPendingOps( protoCmdId, EEnableVideo ) );
+
+ RemoveOperation( protoCmdId );
+
+ if ( videoEnabledByUser && IsFlag( ETwoStageOperation ) )
+ {
+ // Two-phase operation (resume + switch, resume completed)
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL,
+ "MH.video Resume 1st stage" )
+ ClearFlag( ETwoStageOperation );
+ ClearFlag( ESourceUpdateNeeded );
+ iLocalVideo->SelectSourceL( iTempProviderInfo );
+ iTempProviderInfo = CVtEngLocalVideo::KVtEngProviderNone;
+ }
+ else if ( videoEnabledByUser || audioEnabled )
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "MH.video Resume " )
+ CompleteOp( protoResponse );
+ }
+
+ // Do send an intra message
+ if ( IsFlag( EProtoVideoTrackPaused ) )
+ {
+ ClearFlag( EProtoVideoTrackPaused );
+ if ( IsFlag( EProtoSendIntraFrame ) )
+ {
+ RequestFrame();
+ }
+ }
+ }
+ break;
+ case EVtCommandPause: // Audio or video disable
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "MH.protoComC Pause" )
+ __ASSERT_DEBUG( iRequestStatus ||
+ // uninit ongoing, still possible
+ // to receive callback from protocol
+ ( IsPending( EMuteAudio ) != KErrNotFound ||
+ IsPending( EDisableVideo ) != KErrNotFound ),
+ Panic( EVtEngPanicMediaHandlerOpStateFailure ) );
+
+ TBool videoDisabled( EFalse );
+
+ // was command disable audio?
+ if ( MatchResponseToPendingOps( protoCmdId, EMuteAudio ) )
+ {
+ iLocalVideo->Mute();
+ event = KVtEngAudioMuted;
+ }
+ else
+ {
+ // was command disable video?
+ videoDisabled = MatchResponseToPendingOps(
+ protoCmdId, EDisableVideo );
+ if ( videoDisabled )
+ {
+ SetFlag( EProtoVideoTrackPaused );
+ }
+ }
+ RemoveOperation( protoCmdId );
+ if ( IsFlag( ETwoStageOperation ) && videoDisabled )
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL,
+ "MH.video pause 1st stage" )
+ // First event out of two that DisableVideo video
+ // is complete (waiting for event from local video).
+
+ if ( !IsPending( EEnableVideo ) )
+ {
+ ClearFlag( ETwoStageOperation );
+ }
+ else
+ {
+ // Except if pause was not user originated, i.e
+ // pause done in the beginning because there is no
+ // still image to be sent in MT call and video is paused
+ // (user has not yet allowed video sending).
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL,
+ "MH.video paused, 2stage NOT CLEARED" )
+ }
+ }
+ else
+ {
+ if ( !iPauseNoCompleteOp )
+ {
+ CompleteOp( protoResponse );
+ }
+ else
+ {
+ iPauseNoCompleteOp = EFalse;
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL,
+ "MH.video paused due to share stop, clearing flag" )
+ }
+ }
+ }
+ break;
+ case EVtCommandAddDataSink:
+ {
+ __VTPRINT( DEBUG_MEDIA, "LCN: EVtCommandAddDataSink");
+ if ( protoResponse == KErrNone )
+ {
+ __ASSERT_DEBUG( iRequestStatus ||
+ // uninit ongoing, still possible
+ // to receive callback from pv2way
+ ( IsPending( EAddVideoSink ) != KErrNotFound ||
+ IsPending( EAddAudioSink ) != KErrNotFound ),
+ Panic( EVtEngPanicMediaHandlerOpStateFailure ) );
+
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "MH.data sink added" )
+
+ if ( MatchResponseToPendingOps( protoCmdId, EAddVideoSink )
+ && ( iRemoteMediaState & EMediaVideoPreparing ) )
+ {
+ // Video sink added
+ SetFlag( EProtoVideoSinkAdded );
+ iRemoteMediaState &= ~EMediaVideoPreparing;
+ iRemoteMediaState |= EMediaVideo;
+ __VTPRINT( DEBUG_MEDIA, "LCN: EVtCommandAddDataSink for VIDEO OK.");
+ }
+ else if ( MatchResponseToPendingOps( protoCmdId, EAddAudioSink )
+ && ( iRemoteMediaState & EMediaAudioPreparing ) )
+ {
+ // Audio sink added
+ SetFlag( EProtoAudioSinkAdded );
+ iRemoteMediaState &= ~EMediaAudioPreparing;
+ iRemoteMediaState |= EMediaAudio;
+ __VTPRINT( DEBUG_MEDIA, "LCN: EVtCommandAddDataSink for AUDIO OK.");
+ // DevSound created in Proto => temporary devSound needed
+ // for making audio routing work can be released now.
+ CVtEngStateManager* stateManager =
+ CVtEngUtility::StateManager();
+ CVtEngAudioHandler& audioHandler =
+ static_cast< CVtEngAudioHandler& >(
+ stateManager->Handlers().Audio() );
+ audioHandler.SetRoutingEnablerL( EFalse );
+ RequestAudioControllerL();
+ }
+ else
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "MH.protoComC invalid" )
+ Panic( EVtEngPanicMediaHandlerOpStateFailure );
+ }
+ }
+ else
+ {
+ __VTPRINT( DEBUG_MEDIA, "LCN: EVtCommandAddDataSink FAILED");
+
+ if ( MatchResponseToPendingOps( protoCmdId, EAddVideoSink ) )
+ {
+ __VTPRINT( DEBUG_MEDIA, "LCN: EVtCommandAddDataSink FAILED, INCOMING VIDEO");
+
+ iVideoIncomingLogicalChannel.iSameTypeClosingPending = EFalse;
+ if( iVideoIncomingLogicalChannel.iSameTypeChannelReadyToOpen )
+ {
+ iVideoIncomingLogicalChannel.iSameTypeChannelReadyToOpen = EFalse;
+
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE delayed adding VIDEO, ADDing SINK" )
+ AddVideoSink( iVideoIncomingLogicalChannel.iLogicalChannelId );
+ }
+ }
+ else
+ {
+ __VTPRINT( DEBUG_MEDIA, "LCN: EVtCommandAddDataSink FAILED, INCOMING AUDIO");
+
+ iAudioIncomingLogicalChannel.iSameTypeClosingPending = EFalse;
+ if( iAudioIncomingLogicalChannel.iSameTypeChannelReadyToOpen )
+ {
+ iAudioIncomingLogicalChannel.iSameTypeChannelReadyToOpen = EFalse;
+
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE delayed adding AUDIO, ADDing SINK" )
+ AddAudioSink( iAudioIncomingLogicalChannel.iLogicalChannelId );
+ }
+ }
+ }
+ RemoveOperation( protoCmdId );
+ }
+ break;
+ case EVtCommandAddDataSource:
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "MH.data source added" )
+ __VTPRINT( DEBUG_MEDIA, "LCN: EVtCommandAddDataSource");
+ if ( protoResponse == KErrNone &&
+ ( iProtoState == MVtProtocolCommand::EConnected || iProtoState == MVtProtocolCommand::EConnecting || iProtoState == MVtProtocolCommand::ESetup ) )
+ {
+ if ( MatchResponseToPendingOps( protoCmdId, EAddVideoSource ) )
+ {
+ SetFlag( EProtoVideoSourceAdded );
+
+ // This flag was set if channel closed indication
+ // EVtIndicationClosingTrack was received from Proto.
+ ClearFlag( EOutVideoChannelClosed );
+
+ iLocalVideo->VideoChannelOpenedL();
+
+ CVtEngEventManager::NotifyEvent(
+ KVtEngMediaOutgoingVideoChannelStatusChanged );
+
+ __VTPRINT( DEBUG_MEDIA, "LCN: EVtCommandAddDataSource for VIDEO OK.");
+
+ // Adjust to normal value after Connect has completed
+ // so MONA is over.
+ if( iProtoState == MVtProtocolCommand::EConnected )
+ {
+ __VTPRINT( DEBUG_MEDIA, "LCN: Adjusting I Frame Interval in " )
+ __VTPRINT( DEBUG_MEDIA, "LCN: ADD_DATA_SOURCE for Video, Connect has completed earlier." )
+ __VTPRINT( DEBUG_MEDIA, "LCN: Normal I-frame rate." )
+
+
+ // Setting I-Frame interval to normal since MONA connections are over.
+ AddOperation( ESetIFrameInterval,
+ // I-Frame every 10 second.
+ iH263Encoder->SetIntraFrameInterval( 100 ) );
+ }
+ else if( iProtoState == MVtProtocolCommand::EConnecting || iProtoState == MVtProtocolCommand::ESetup )
+ {
+ __VTPRINT( DEBUG_MEDIA, "LCN: Adjusting I Frame Interval in " )
+ __VTPRINT( DEBUG_MEDIA, "LCN: ADD_DATA_SOURCE for Video, Proto state Connecting." )
+ __VTPRINT( DEBUG_MEDIA, "LCN: High I-frame rate" )
+
+ // MONA negotiations ongoing, I-Frame invertal must be small
+ AddOperation( ESetIFrameInterval,
+ // 10 I-Frames every 1 second.
+ iH263Encoder->SetIntraFrameInterval( 10000 ) );
+ }
+
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL,
+ "MH.data setting default videoquality" )
+
+ // Set default frame rate and send indication to peer
+ if ( !IsFlag( EVideoQualitySetByPeer ) )
+ {
+ SetVideoQualityL( EVideoQualityNormal, EFalse );
+ }
+
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL,
+ "MH.data source added check flag" )
+ if ( IsFlag( EProtoPauseVideoRequested ) )
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL,
+ "MH.data source added pausing video" )
+ EnableVideoL( EFalse );
+ }
+ }
+ else if ( MatchResponseToPendingOps(
+ protoCmdId, EAddAudioSource ) )
+ {
+ SetFlag( EProtoAudioSourceAdded );
+
+ // This flag was set if channel closed indication
+ // EVtIndicationClosingTrack was received from PV.
+ ClearFlag( EOutAudioChannelClosed );
+
+ CVtEngEventManager::NotifyEvent(
+ KVtEngMediaOutgoingAudioChannelStatusChanged );
+
+ __VTPRINT( DEBUG_MEDIA, "LCN: EVtCommandAddDataSource for AUDIO OK.");
+ }
+ }
+
+ else
+ {
+ __VTPRINT( DEBUG_MEDIA, "LCN: EVtCommandAddDataSource FAILED");
+
+ if ( MatchResponseToPendingOps( protoCmdId, EAddVideoSource ) )
+ {
+ __VTPRINT( DEBUG_MEDIA, "EVtCommandAddDataSource FAILED, OUTGOING VIDEO");
+
+ iVideoOutgoingLogicalChannel.iSameTypeClosingPending = EFalse;
+ if( iVideoOutgoingLogicalChannel.iSameTypeChannelReadyToOpen )
+ {
+ iVideoOutgoingLogicalChannel.iSameTypeChannelReadyToOpen = EFalse;
+
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE delayed adding VIDEO, ADDing SOURCE" )
+ AddVideoSource( iVideoOutgoingLogicalChannel.iLogicalChannelId );
+ }
+ }
+ else
+ {
+ __VTPRINT( DEBUG_MEDIA, "LCN: EVtCommandAddDataSource FAILED, OUTGOING AUDIO");
+
+ iAudioOutgoingLogicalChannel.iSameTypeClosingPending = EFalse;
+ if( iAudioOutgoingLogicalChannel.iSameTypeChannelReadyToOpen )
+ {
+ iAudioOutgoingLogicalChannel.iSameTypeChannelReadyToOpen = EFalse;
+
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE delayed adding AUDIO, ADDing SOURCE" )
+ AddAudioSource( iAudioOutgoingLogicalChannel.iLogicalChannelId );
+ }
+ }
+ }
+
+ if ( !RemoveOperation( protoCmdId ) )
+ {
+ __ASSERT_DEBUG( iRequestStatus != NULL,
+ // uninit ongoing, still possible to receive
+ // callback from protocol
+ Panic( EVtEngPanicMediaHandlerOpStateFailure ) );
+ }
+ states->Update();
+ break;
+ }
+
+ case EVtCommandConnect:
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "MH.Connect complete" )
+ if ( protoResponse == KErrNone )
+ {
+ __ASSERT_DEBUG( IsPending( EConnectProto ) != KErrNotFound,
+ Panic( EVtEngPanicMediaHandlerOpStateFailure ) );
+ RemoveOperation( EConnectProto );
+ iProtoState = MVtProtocolCommand::EConnected;
+ __VTPRINT( DEBUG_MEDIA, "MH.protoComC: EConnected" )
+ states->Update();
+
+ // Adjust only if VideoSource adding has compled
+ if( IsPending( EAddVideoSource ) == KErrNotFound )
+ {
+ __VTPRINT( DEBUG_MEDIA, "LCN: Adjusting I FrameInterval " )
+ __VTPRINT( DEBUG_MEDIA, "LCN: after Connect has completed" )
+ __VTPRINT( DEBUG_MEDIA, "LCN: Normal I-frame interval." )
+
+
+ // Setting I-Frame interval to normal since MONA connections are over.
+ AddOperation( ESetIFrameInterval,
+ // I-Frame every 10 second.
+ iH263Encoder->SetIntraFrameInterval( 100 ) );
+ }
+ }
+ else
+ {
+ if ( iProtoState == MVtProtocolCommand::EConnecting ) {
+ // it is possible that we're here because call was hanged up
+ iProtoState = MVtProtocolCommand::ESetup;
+ }
+ RemoveOperation( EConnectProto );
+ // connect may have failed due to disconnect request (possible only in debug env?)
+ if ( iPendingOp &&
+ ( iPendingOp->Command() == KVtEngTerminateSession ) )
+ {
+ __VTPRINT( DEBUG_MEDIA,
+ "complete KVtEngTerminateSession on connect failure" )
+ CompleteOp( KErrNone );
+ }
+ else
+ {
+ __VTPRINT( DEBUG_MEDIA,
+ "request fallback on connect failure" )
+ // request fallback from telephony
+ CVtEngUtility* utils = CVtEngUtility::EngineUtils();
+ utils->MediatorCommands().VoiceFallback();
+ }
+ states->Update();
+ }
+ }
+ break;
+ case EVtCommandRemoveDataSource:
+ case EVtCommandRemoveDataSink:
+ break;
+ case EVtCommandReset:
+ {
+ __ASSERT_DEBUG( IsPending( EDestructProtoPhaseReset ) != KErrNotFound,
+ Panic( EVtEngPanicMediaHandlerOpStateFailure ) );
+ __VTPRINT( DEBUG_MEDIA, "MH.protoComC:RESET complete" )
+ RemoveOperation( protoCmdId );
+ if ( protoResponse == KErrNone )
+ {
+ iProtoState = MVtProtocolCommand::EIdle;
+ __VTPRINT( DEBUG_MEDIA, "MH.protoComC: EIdle" )
+ }
+ if ( iRequestStatus )
+ {
+ // we're in uninitialization process
+ // do this even if reset failed!
+ iLocalVideo->StopViewFinder();
+ UninitializeNextStep();
+ }
+ states->Update();
+ }
+ break;
+ case EVtCommandDeleteProtocolInterface:
+ {
+
+ // Remove pending operation from list
+ RemoveOperation( protoCmdId );
+
+ // Proceed to disconnecting if inetrfaces are free'd
+ UninitializeNextStep();
+ states->Update();
+
+ break;
+ }
+ case EVtCommandDisconnect:
+ {
+ __ASSERT_DEBUG(
+ IsPending( EDestructProtoPhaseDisconnect ) != KErrNotFound ||
+ IsPending( ETerminateSession ) != KErrNotFound,
+ Panic( EVtEngPanicMediaHandlerOpStateFailure ) );
+ __VTPRINT( DEBUG_MEDIA, "MH.protoComC:DISCONNECT complete" )
+ if ( protoResponse == KErrNone )
+ {
+ iProtoState = MVtProtocolCommand::ESetup;
+ __VTPRINT( DEBUG_MEDIA, "MH.protoComC: ESetup_disconnect" )
+ }
+
+ delete iTimer;
+ iTimer = NULL;
+
+ RemoveOperation( protoCmdId );
+
+ // If disconnect was requested while connecting we
+ // have connect operation added.
+ RemoveOperation( EConnectProto );
+
+ if ( iRequestStatus )
+ {
+ // continue uninitialization
+ UninitializeNextStep();
+ }
+ else
+ {
+ // complete plain disconnect request from UI
+ CompleteOp( protoResponse );
+ }
+ states->Update();
+ }
+ break;
+ case EVtCommandCancelAllCommands:
+ {
+ __ASSERT_DEBUG(
+ IsPending( EUninitializeCancelAllProto ) != KErrNotFound,
+ Panic( EVtEngPanicMediaHandlerOpStateFailure ) );
+ RemoveOperation( protoCmdId );
+
+ UninitializeNextStep();
+ }
+ break;
+ default:
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.protoComC Unknown Proto reply" )
+ }
+ break;
+ }
+ if ( event != KVtEngEventNone )
+ {
+ CVtEngEventManager::NotifyEvent( event );
+ }
+ __VTPRINTEXIT( "MH.HandleSessionCommandEventL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::HandleSessionInformationalEventL
+// Handles event from protocol engine.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::HandleSessionInformationalEventL(
+ const TVtIndicationEvent& aEvent)
+ {
+ __VTPRINTENTER( "MH.InfoEvent" )
+ const TInt type( aEvent.iEventType );
+ __VTPRINT2( DEBUG_MEDIA, "MH.protoHIE type=%d", type )
+
+ TVtIndicationEvent& event =
+ const_cast<TVtIndicationEvent&>(aEvent);
+ const TUint8* buffer = event.iLocalBuffer;
+
+ if ( buffer || type == EVtIndicationDisconnect )
+ {
+ TBool video( EFalse );
+ TBool audio( EFalse );
+ __VTPRINT( DEBUG_MEDIA, "MH.protoHIE inbound")
+ if ( type != EVtIndicationDisconnect &&
+ type != EVtIndicationUserInputCapability )
+ {
+ switch ( buffer[0] )
+ {
+ case EVtAudio:
+ audio = ETrue;
+ break;
+ case EVtVideo:
+ video = ETrue;
+ break;
+ case EVtControl:
+ case EVtData:
+ case EVtMediaNone:
+ __VTPRINTEXIT( "MH.InfoEvent" )
+ return;
+
+ default:
+ break;
+
+ }
+ }
+
+ __VTPRINT( DEBUG_MEDIA, "MH.protoHIE acting according" )
+ TInt event( KVtEngEventNone );
+ switch ( type )
+ {
+ case EVtIndicationIncomingTrack:
+ {
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE EVtIndicationIncomingTrack" )
+ if ( video )
+ {
+ TInt tempID = *((TInt*)(buffer+4));
+ __VTPRINT2( DEBUG_MEDIA, "LCN: MH.protoHIE INCOMING VIDEO:%d", tempID )
+
+ if( !iVideoIncomingLogicalChannel.iSameTypeClosingPending )
+ {
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE InTrack VIDEO, ADDing SINK" )
+ AddVideoSink( tempID );
+ }
+ else
+ {
+ // Store old value since ID will change when we get outgoing track indication
+ iVideoIncomingLogicalChannel.iLogicalChannelIdClosing = iVideoIncomingLogicalChannel.iLogicalChannelId;
+ iVideoIncomingLogicalChannel.iSameTypeChannelReadyToOpen = ETrue;
+ }
+
+ // Store new LCN ID.
+ iVideoIncomingLogicalChannel.iLogicalChannelId = tempID;
+ }
+ else if ( audio )
+ {
+ TInt tempID = *((TInt*)(buffer+4));
+ __VTPRINT2( DEBUG_MEDIA, "LCN: MH.protoHIE INCOMING AUDIO:%d", tempID )
+
+ if( !iAudioIncomingLogicalChannel.iSameTypeClosingPending )
+ {
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE InTrack AUDIO, ADDing SINK" )
+ AddAudioSink( tempID );
+ }
+ else
+ {
+ // Store old value since ID will change when we get outgoing track indication
+ iAudioIncomingLogicalChannel.iLogicalChannelIdClosing = iAudioIncomingLogicalChannel.iLogicalChannelId;
+ iAudioIncomingLogicalChannel.iSameTypeChannelReadyToOpen = ETrue;
+ }
+
+ // Store new LCN ID.
+ iAudioIncomingLogicalChannel.iLogicalChannelId = tempID;
+ }
+ }
+ break;
+
+ case EVtIndicationOutgoingTrack:
+ {
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE EVtIndicationOutgoingTrack" )
+ if ( video )
+ {
+ TInt tempID = *((TInt*)(buffer+4));
+ __VTPRINT2( DEBUG_MEDIA, "LCN: MH.protoHIE OUTGOING VIDEO ID:%d", tempID )
+
+ if( !iVideoOutgoingLogicalChannel.iSameTypeClosingPending )
+ {
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE OutTrack VIDEO, ADDing SOURCE" )
+ AddVideoSource( tempID );
+ }
+ else
+ {
+ // Store old value since ID will change when we get outgoing track indication
+ iVideoOutgoingLogicalChannel.iLogicalChannelIdClosing = iVideoOutgoingLogicalChannel.iLogicalChannelId;
+ iVideoOutgoingLogicalChannel.iSameTypeChannelReadyToOpen = ETrue;
+ }
+
+ // Store new LCN ID.
+ iVideoOutgoingLogicalChannel.iLogicalChannelId = tempID;
+ }
+ else if ( audio )
+ {
+
+ TInt tempID = *((TInt*)(buffer+4));
+ __VTPRINT2( DEBUG_MEDIA, "LCN: MH.protoHIE OUTGOING AUDIO:%d", tempID )
+
+ if( !iAudioOutgoingLogicalChannel.iSameTypeClosingPending )
+ {
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE OutTrack AUDIO, ADDing SOURCE" )
+ AddAudioSource( tempID );
+ }
+ else
+ {
+ // Store old value since ID will change when we get outgoing track indication
+ iAudioOutgoingLogicalChannel.iLogicalChannelIdClosing = iAudioOutgoingLogicalChannel.iLogicalChannelId;
+ iAudioOutgoingLogicalChannel.iSameTypeChannelReadyToOpen = ETrue;
+ }
+
+ // Store new LCN ID.
+ iAudioOutgoingLogicalChannel.iLogicalChannelId = tempID;
+ }
+ }
+ break;
+
+ case EVtIndicationClosingTrack:
+ {
+
+ TUint8 direction = buffer[0];
+ TInt tempID = *((TInt*)(buffer+4));
+
+ __VTPRINT3( DEBUG_MEDIA, "LCN: MH.protoHIE PEVtIndicationClosingTrack ID:%d, dir:%d", tempID, direction )
+
+ if( direction == EVtIncoming )
+ {
+ if( tempID == iVideoIncomingLogicalChannel.iLogicalChannelId )
+ {
+ iVideoIncomingLogicalChannel.iSameTypeClosingPending = ETrue;
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE CLOSING INCOMING VIDEO" )
+ }
+ else
+ {
+ iAudioIncomingLogicalChannel.iSameTypeClosingPending = ETrue;
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE CLOSING INCOMING AUDIO" )
+ }
+ }
+ else
+ {
+ TInt uiEvent;
+ if( tempID == iVideoOutgoingLogicalChannel.iLogicalChannelId )
+ {
+ SetFlag( EOutVideoChannelClosed );
+ iVideoOutgoingLogicalChannel.iSameTypeClosingPending = ETrue;
+ uiEvent = KVtEngMediaOutgoingVideoChannelStatusChanged;
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE CLOSING OUTGOING VIDEO" )
+ }
+ else
+ {
+ SetFlag( EOutAudioChannelClosed );
+ iAudioOutgoingLogicalChannel.iSameTypeClosingPending = ETrue;
+ uiEvent = KVtEngMediaOutgoingAudioChannelStatusChanged;
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE CLOSING OUTGOING AUDIO" )
+ }
+ CVtEngEventManager::NotifyEvent( uiEvent );
+ }
+ }
+ break;
+
+ case EVtIndicationCloseTrack:
+ {
+
+ TInt tempID = *((TInt*)(buffer+4));
+
+ TUint8 direction = buffer[0];
+
+ __VTPRINT3( DEBUG_MEDIA, "LCN: MH.protoHIE EVtIndicationCloseTrack ID:%d, dir:%d", tempID, direction )
+
+ if( direction == EVtIncoming )
+ {
+ if( iVideoIncomingLogicalChannel.iLogicalChannelId == tempID ||
+ ( iVideoIncomingLogicalChannel.iSameTypeClosingPending &&
+ tempID == iVideoIncomingLogicalChannel.iLogicalChannelIdClosing )
+ )
+ {
+ iVideoIncomingLogicalChannel.iSameTypeClosingPending = EFalse;
+ iRemoteMediaState &= ~EMediaVideo;
+
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE CLOSE INCOMING VIDEO" )
+
+ if( iVideoIncomingLogicalChannel.iSameTypeChannelReadyToOpen )
+ {
+ iVideoIncomingLogicalChannel.iSameTypeChannelReadyToOpen = EFalse;
+
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE delayed adding VIDEO, ADDing SINK" )
+ AddVideoSink( iVideoIncomingLogicalChannel.iLogicalChannelId );
+ }
+ }
+ else
+ {
+ iAudioIncomingLogicalChannel.iSameTypeClosingPending = EFalse;
+
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE CLOSE INCOMING AUDIO" )
+
+ if( iAudioIncomingLogicalChannel.iSameTypeChannelReadyToOpen )
+ {
+ iAudioIncomingLogicalChannel.iSameTypeChannelReadyToOpen = EFalse;
+
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE delayed adding AUDIO, ADDing SINK" )
+ AddAudioSink( iAudioIncomingLogicalChannel.iLogicalChannelId );
+ }
+ }
+ }
+ else
+ {
+ if( iVideoOutgoingLogicalChannel.iLogicalChannelId == tempID ||
+ ( iVideoOutgoingLogicalChannel.iSameTypeClosingPending &&
+ tempID == iVideoOutgoingLogicalChannel.iLogicalChannelIdClosing )
+ )
+ {
+ iVideoOutgoingLogicalChannel.iSameTypeClosingPending = EFalse;
+
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE CLOSE OUTGOING VIDEO" )
+
+ if( iVideoOutgoingLogicalChannel.iSameTypeChannelReadyToOpen )
+ {
+ iVideoOutgoingLogicalChannel.iSameTypeChannelReadyToOpen = EFalse;
+
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE delayed adding VIDEO, ADDing SOURCE" )
+ AddVideoSource( iVideoOutgoingLogicalChannel.iLogicalChannelId );
+ }
+ }
+ else
+ {
+ iAudioOutgoingLogicalChannel.iSameTypeClosingPending = EFalse;
+
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE CLOSE OUTGOING AUDIO" )
+
+ if( iAudioOutgoingLogicalChannel.iSameTypeChannelReadyToOpen )
+ {
+ iAudioOutgoingLogicalChannel.iSameTypeChannelReadyToOpen = EFalse;
+
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.protoHIE delayed adding AUDIO, ADDing SOURCE" )
+ AddAudioSource( iAudioOutgoingLogicalChannel.iLogicalChannelId );
+ }
+ }
+ }
+ }
+ break;
+ case EVtIndicationResumeTrack:
+ __VTPRINT2( DEBUG_MEDIA, "MH.protoHIE X is resumed %d", buffer[1] )
+ if ( buffer[1] == EVtIncoming ) // Only for remote
+ {
+ if ( video )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.protoHIE video resumed" )
+ event = KVtEngRemoteVideoResumed;
+ ClearFlag( EProtoVideoTrackPaused );
+ }
+ else if ( audio )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.protoHIE audio resumed" )
+ event = KVtEngRemoteAudioResumed;
+ ClearFlag( EProtoAudioTrackPaused );
+ }
+ }
+ break;
+ case EVtIndicationPauseTrack:
+ __VTPRINT2( DEBUG_MEDIA, "MH.protoHIE X is paused %d", buffer[1] )
+ if ( buffer[1] == EVtIncoming ) // Only for remote
+ {
+ if ( audio )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.protoHIE audio paused" )
+ SetFlag( EProtoAudioTrackPaused );
+ event = KVtEngRemoteAudioPaused;
+ }
+ else if ( video )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.protoHIE video paused" )
+ SetFlag( EProtoVideoTrackPaused );
+ event = KVtEngRemoteVideoPaused;
+ }
+ }
+ break;
+ case EVtIndicationDisconnect:
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_RETURN, "MH.protoHIE PID" )
+
+ // Fix for disconnecting remote (bearer). Engine
+ // needs to send KVtEngRemoteDisconnect event to UI to notify
+ // UI that call can not be hangup!
+ CVtEngEventManager::NotifyEvent( KVtEngRemoteDisconnect );
+
+ delete iTimer;
+ iTimer = NULL;
+ CVtEngStateManager* states = CVtEngUtility::StateManager();
+ iProtoState = MVtProtocolCommand::ESetup;
+ __VTPRINT( DEBUG_MEDIA, "MH.protoComC: ESetup_indi_disconnect" )
+ states->Update();
+ if ( iPendingOp &&
+ ( iPendingOp->Command() == KVtEngTerminateSession ||
+ iPendingOp->Command() == KVtEngResetEngine ) )
+ {
+ __VTPRINT2( DEBUG_MEDIA, "MH.protoHIE PID PO", iPendingOp->Command() )
+ // Complete only KVtEngTerminateSession, if KVtEngResetEngine
+ // is pending complete it after uninitialisation is finalised.
+ if ( iPendingOp->Command() == KVtEngTerminateSession )
+ {
+ CompleteOp( KErrNone );
+ }
+ }
+ else
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_RETURN, "MH.protoHIE PID RO")
+ UninitializeNextStep();
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ if ( KVtEngEventNone != event )
+ {
+ CVtEngEventManager::NotifyEvent( event );
+ }
+ }
+ __VTPRINTEXIT( "MH.InfoEvent" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::HandleSessionErrorEventL
+// Handles error event from protocol engine.
+// -----------------------------------------------------------------------------
+//
+#ifdef VTDEBUG
+void CVtEngMediaHandler::HandleSessionErrorEventL( const TVtErrorEvent& aEvent )
+#else
+void CVtEngMediaHandler::
+ HandleSessionErrorEventL( const TVtErrorEvent& /* aEvent */ )
+#endif // VTDEBUG
+ {
+ // Must have an implementation.
+ __VTPRINT2( DEBUG_MEDIA, "MH.protoHEE,%d", aEvent.iEventType )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::HandleSettingChangedL
+// Handles still image setting change.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::HandleSettingChangedL(
+ CVtEngSettings::TSettingId aId,
+ const TDesC& /*aValue*/ )
+ {
+ __VTPRINTENTER( "MH.HandleSettingChangedL" )
+ if ( aId == CVtEngSettings::ESelectVolume ||
+ aId == CVtEngSettings::EHandsetVolume ||
+ aId == CVtEngSettings::EHandsfreeVolume )
+ {
+ __VTPRINT2( DEBUG_MEDIA, "MH.volChgd %d", aId )
+ UpdateVolume();
+
+ if ( aId == CVtEngSettings::EHandsetVolume ||
+ aId == CVtEngSettings::EHandsfreeVolume )
+ {
+ CVtEngEventManager::NotifyEvent(
+ KVtEngAudioOutputVolumeChanged );
+ }
+ }
+ else if ( aId == CVtEngSettings::EStillImage ||
+ aId == CVtEngSettings::EStillImagePath )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.stillChgd" )
+
+ TShareObjectState shareState;
+ GetObjectSharingState( shareState );
+ if ( shareState == EInitializingShareImage ||
+ shareState == ESharingImage )
+ {
+ iLocalVideo->SettingsChanged();
+ return;
+ }
+
+ CVtEngSettings& settings = CVtEngUtility::Settings();
+ const CVtEngSettings::TVtEngVideoCallConfig& config =
+ settings.Config();
+
+ const CVtEngLocalVideo::TVtEngProviderType
+ activeProvider( iLocalVideo->ActiveProvider() );
+ if ( config.iVideo.iImageIsValid )
+ {
+ __VTPRINT( DEBUG_GEN, "MH.HSC valid" )
+ EnableVideoL( ETrue );
+ // if still image is not active we should only
+ // initialize it, not start after initialization.
+ const TBool initOnly( activeProvider ==
+ CVtEngLocalVideo::KVtEngProviderCam1 ||
+ activeProvider == CVtEngLocalVideo::KVtEngProviderCam2 ||
+ activeProvider ==
+ CVtEngLocalVideo::KVtEngProviderShareImage );
+ iLocalVideo->InitializeOnlyEx( initOnly );
+ TRAPD( err,iLocalVideo->SetStillImageL( !initOnly ) );
+ if ( err == KErrNotReady )
+ {
+ __VTPRINT( DEBUG_GEN, "MH.HSC waiting...")
+ // Another switch ongoing, wait until it is done.
+ }
+ }
+ else
+ {
+ __VTPRINT( DEBUG_GEN, "MH.HSC invalid" )
+ __VTPRINT2( DEBUG_MEDIA, "MH.HSC provider=", activeProvider )
+ if ( CVtEngUtility::Settings().IsDefaultStillImageDefined() )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.SetDefaultStillImageL" )
+ if ( activeProvider == CVtEngLocalVideo::KVtEngProviderImage )
+ {
+ iLocalVideo->SetDefaultStillImageL();
+ }
+ }
+ else
+ {
+ if( activeProvider !=
+ CVtEngLocalVideo::KVtEngProviderCam1 &&
+ activeProvider != CVtEngLocalVideo::KVtEngProviderCam2 )
+ {
+ EnableVideoL( EFalse );
+ }
+ __VTPRINT( DEBUG_MEDIA, "MH.tStillImageL" )
+ iLocalVideo->SetStillImageL( ETrue );
+ }
+
+ }
+ }
+ else
+ {
+ // Do nothing, but satisfy lint.
+ __VTPRINT2( DEBUG_MEDIA, "MH.HSC not handled=%d", aId )
+ }
+ __VTPRINTEXIT( "MH.HSC" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::InitializeL
+// Initializes settings listeners.
+// Sets still image and initializes default provider.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::InitializeL( TRequestStatus& aStatus )
+ {
+ __VTPRINTENTER( "MH.InitializeL" )
+ // configure still image
+ CVtEngSettings& settings = CVtEngUtility::Settings();
+ settings.NotifyChangeL( CVtEngSettings::EStillImage, *this );
+ settings.NotifyChangeL( CVtEngSettings::EStillImagePath, *this );
+ settings.NotifyChangeL( CVtEngSettings::ESelectVolume, *this );
+ settings.NotifyChangeL( CVtEngSettings::EHandsetVolume, *this );
+ settings.NotifyChangeL( CVtEngSettings::EHandsfreeVolume, *this );
+
+ const CVtEngSettings::TVtEngVideoCallConfig& config = settings.Config();
+ TInt err( KErrNotFound );
+ if ( config.iVideo.iImageIsValid )
+ {
+ // first step initialize still, when that is complete, initialize blank
+ TRAP( err, iLocalVideo->SetStillImageL( ETrue ) );
+ if ( err == KErrNone )
+ {
+ iVSInitState = EStateInitStillImage;
+ iRequestStatus = &aStatus;
+ }
+ }
+ if ( err != KErrNone )
+ {
+ // Still provider init failed -> initialize blank
+ InitializeProviderL( aStatus );
+ }
+ __VTPRINTEXIT( "MH.InitializeL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::CancelInitialize
+// Sets initialization state as cancelled.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::CancelInitialize()
+ {
+ __VTPRINTENTER( "MH.CancelInitialize" )
+ iVSInitState = EStateInitCanceled;
+ __VTPRINTEXIT( "MH.CancelInitialize" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::InitializeProviderL
+// Initializes default blank provider.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::InitializeProviderL( TRequestStatus& aStatus )
+ {
+ __VTPRINTENTER( "MH.InitializeProviderL" )
+ iLocalVideo->InitializeL();
+ iVSInitState = EStateInitProvider;
+ iRequestStatus = &aStatus;
+ __VTPRINTEXIT( "MH.InitializeProviderL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::Uninitialize
+// Frees all resources.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::Uninitialize( TRequestStatus& aStatus )
+ {
+ __VTPRINTENTER( "MH.Uninitialize" )
+ ClearFlag( ETwoStageOperation );
+ ClearFlag( ESourceUpdateNeeded );
+ iRequestStatus = &aStatus;
+ if ( iProtoState == MVtProtocolCommand::EDisconnecting )
+ {
+ // Protocol is disconnecting if
+ // 1) bearer was lost (and videoteleng issued disconnect on protocol), or
+ // 2) protocol issued disconnect due unrecoverable error or disconnect
+ // request from remote terminal.
+ // And now UI requested 'reset engine' while performing disconnect.
+ // When disconnecting is complete check if iRequestStatus
+ // is not null AND iInitialized is ETrue.
+ // If so, Uninitialize has been called (UI requested reset).
+
+ StopRendering();
+ __VTPRINT( DEBUG_MEDIA, "MH.UnInit wait for disconnect to complete" )
+ __VTPRINTEXIT( "MH.Uninitialize" )
+ return;
+ }
+ iInitialized = EFalse;
+ UninitializeNextStep();
+ __VTPRINTEXIT( "MH.Uninitialize" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::UninitializeNextStep
+// Goes to next step in uninitialization
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::UninitializeNextStep( )
+ {
+ __VTPRINTENTER( "MH.UninitializeNextStep" )
+ StopRendering();
+
+ TOperation op( ENone );
+
+ // CancelAllProtoCommands is no op if nothing to cancel or already pending.
+ // However, then op is still assigned with EUninitializeCancelAllProto to
+ // indicate it is pending and we must wait for it to complete.
+ CancelAllProtoCommands( op );
+
+ if ( op == ENone ) // Cancellation is not pending
+ {
+ __VTPRINT2( DEBUG_MEDIA, "next step protostate=%d", iProtoState )
+ switch ( iProtoState )
+ {
+ case MVtProtocolCommand::EConnected:
+ case MVtProtocolCommand::EConnecting:
+ op = EDestructProtoPhaseDisconnect;
+ break;
+ case MVtProtocolCommand::ESetup:
+ // In EInitializing state operation is waited to complete. See
+ // CVtEngInitializer::ContinueOrRetry op==EReset and iStep==EInitProto
+
+ if( iH324Config || iH263Encoder )
+ {
+ // First remove interfaces, after completion perform reset
+ op = ERemove324CtrlInterface;
+ break;
+ }
+
+ // If interfaces are already released or not even reserved, go to Reset.
+ op = EDestructProtoPhaseReset;
+ break;
+ case MVtProtocolCommand::EResetting:
+ // Reset ongoing, wait for it to complete
+ __VTPRINT( DEBUG_MEDIA, "MH.UnInit resetting" )
+ break;
+ case MVtProtocolCommand::EIdle:
+ op = ERemove324CtrlInterface;
+ __VTPRINT( DEBUG_MEDIA, "MH.UnInit idling" )
+ break;
+ default:
+ __VTPRINT( DEBUG_MEDIA, "MH.UnInit invalid state" )
+ break;
+ }
+ if ( op != ENone )
+ {
+ TRAPD( err, ContinueUninitializeL( op ) );
+ if ( err != KErrNone )
+ {
+ if ( iRequestStatus )
+ {
+ User::RequestComplete( iRequestStatus, err );
+ iRequestStatus = NULL;
+ }
+ else
+ {
+ // Infinite waiting for end state!
+ __VTPRINT( DEBUG_MEDIA, "MH. dead end!" )
+ Panic( EVtEngPanicDisconnectTimerExpired );
+ }
+ __VTPRINT2( DEBUG_MEDIA, "next step err=%d", err )
+ }
+ }
+ }
+ __VTPRINTEXIT( "MH.UninitializeNextStep" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::ContinueUninitializeL
+// Completes uninitialization:
+// does disconnecting, deletes members.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::ContinueUninitializeL(
+ const TOperation aOp )
+ {
+ __VTPRINTENTER( "MH.ContinueUninitializeL" )
+ __VTPRINT2( DEBUG_MEDIA, "MH.ContUn op=%d", aOp)
+ switch ( aOp )
+ {
+ case EDestructProtoPhaseDisconnect: // causes DisconnectL on protocol
+ __VTPRINT2( DEBUG_MEDIA, "MH.ContUn EDestructProtoPhaseDisconnect iProtoState=%d", iProtoState )
+
+ // Disconnecting only allowed in Connecting and Connected state.
+ if( iProtoState == MVtProtocolCommand::EConnecting || iProtoState == MVtProtocolCommand::EConnected )
+ {
+ DisconnectProtoL();
+ if ( iProtoState == MVtProtocolCommand::EDisconnecting ) {
+ // started succefully disconnecting
+ break;
+ }
+ }
+ // fall through if state was not proper was disconnect
+ case EDestructProtoPhaseReset: // causes ResetL on protocol
+
+ ResetProto2WayL();
+ if ( iProtoState == MVtProtocolCommand::EResetting )
+ {
+ break;
+ }
+ // fall through if state was not proper for reset
+ case ERemove324CtrlInterface:
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.ContUn ERemove324CtrlInterface" )
+ const TBool extCmdPending( ExtensionCommandsPending() );
+ if ( !extCmdPending && ( iH324Config || iH263Encoder ) )
+ { // no pending extension commands, interfaces can be released
+ // this is no-op if already released
+ ReleaseProtoInterfacesL();
+ break;
+ }
+ if( extCmdPending ||
+ IsPending( ERemove324CtrlInterface ) != KErrNotFound ||
+ IsPending( ERemoveH263EncInterface ) != KErrNotFound )
+ {
+ // Interface releasing has not completed yet, need to wait
+ // until proceeding ahead.
+ break;
+ }
+ }
+ // fall through if interfaces are released
+ case EDestructSwitchBlank:
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.ContUn EDestructSwitchBlank" )
+ // provider must be selected to something else that
+ // is not deleted
+ const CVtEngLocalVideo::TVtEngProviderType
+ activeProvider( iLocalVideo->ActiveProvider() );
+ if ( activeProvider != CVtEngLocalVideo::KVtEngProviderNone )
+ {
+ iLocalVideo->SelectSourceL( CVtEngLocalVideo::KVtEngProviderNone );
+ iVSInitState = EStateWaitingProviderChangeForUninit;
+ break;
+ }
+ // blank provider already active so continue
+ iVSInitState = EInitStateNone;
+ }
+ // fall thru
+ case EDestructInternals:
+ __VTPRINT( DEBUG_MEDIA, "MH.ContUn EDestructInternals" )
+ iLocalVideo->Reset();
+ delete iRemoteVideo;
+ iRemoteVideo = NULL;
+ if ( iRequestStatus )
+ {
+ User::RequestComplete( iRequestStatus, KErrNone );
+ iRequestStatus = NULL;
+ }
+ break;
+ default:
+ // Should not happen
+ Panic( EVtEngPanicUnInitIncorrectOperation );
+ break;
+ }
+
+ __VTPRINTEXIT( "MH.ContinueUninitializeL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::StopRendering
+// Stops all rendering.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::StopRendering()
+ {
+ __VTPRINTENTER( "MH.StopRendering" )
+ if ( iLocalVideo )
+ {
+ iLocalVideo->StopViewFinder();
+ }
+ if ( iRemoteVideo )
+ {
+ iRemoteVideo->StopVideoRendering();
+ }
+ __VTPRINTEXIT( "MH.StopRendering" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::UpdateVolume
+// Updates volume values.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::UpdateVolume()
+ {
+ __VTPRINTENTER( "MH.UpdateVolume" )
+ if ( iUpdateVolumeAllowed && IsPending( ESetAudioVolume ) == KErrNotFound )
+ {
+ CVtEngSettings& settings = CVtEngUtility::Settings();
+
+ TInt volume( 0 );
+ TInt err( settings.GetVolume( volume,
+ settings.CurrentVolume(), ETrue ) );
+ if ( err != KErrNone )
+ {
+ volume = settings.MinVolume();
+ }
+
+ SetVolume( volume );
+ }
+ else
+ {
+ iUpdateVolumeRequired = ETrue;
+ }
+ __VTPRINTEXIT( "MH.UpdateVolume" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::AutoEnableVideo
+// Enables video when primary camera becomes available while blank provider
+// is active (i.e. video is disabled). This should not be called in other
+// occations. Difference to EnableVideoL is that callback doesn't try to
+// complete pending request to UI (that usually is different request than this).
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::AutoEnableVideo( TBool aEnable )
+ {
+ __VTPRINTENTER( "MH.AutoEnableVideo" )
+ __VTPRINT( DEBUG_MEDIA, "MH.AutoEnableVideo" )
+ TOperation op( EDisableVideoInternal );
+ if ( aEnable )
+ {
+ op = EEnableVideoInternal;
+ }
+ TRAPD( err, EnableVideoL( aEnable, op ) );
+ __VTPRINTEXITR( "MH.AutoEnableVideo %d", err )
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::FinalizeUninitialization
+// Deletes protocol.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::FinalizeUninitialization()
+ {
+ __VTPRINTENTER( "MH.FinalUninit" )
+ if ( iSessionCommand )
+ {
+ iAudioCtrl = NULL;
+ TInt err( KErrNone );
+
+ // Delete the config interface
+ TRAP( err,
+ {
+ if ( iSessionCommand )
+ {
+ VTProtocolFactory::DeleteSessionCommand( iSessionCommand );
+ iSessionCommand = NULL;
+ }
+
+ // Trapped to log the possible error
+ __VTPRINT( DEBUG_MEDIA, "MH.Deleted Terminal" )
+ } );
+ __VTPRINT2( DEBUG_MEDIA, "MH.Deletion complete=%d", err )
+ iSessionCommand = NULL;
+ iProtoStateFlags = 0;
+ iProtoState = MVtProtocolCommand::EIdle;
+ __VTPRINT( DEBUG_MEDIA, "MH.protoComC: EIdle uninit" )
+ if ( iPendingOp &&
+ iPendingOp->Command() == KVtEngTerminateSession )
+ {
+ __VTPRINT2( DEBUG_MEDIA, "MH.FinalUninit comp TerminateSession=%d",
+ iPendingOp->Command())
+ CompleteOp( KErrNone );
+ }
+ else if ( iPendingOp ) {
+ __VTPRINT2( DEBUG_MEDIA, "MH.FinalUninit comp =%d",
+ iPendingOp->Command() )
+ delete iPendingOp;
+ }
+ iPendingOp = NULL;
+ }
+ iPendingOps->Reset();
+ __VTPRINTEXIT( "MH.FinalUninit" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::ResetProto2WayL
+// Resets protocol engine.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::ResetProto2WayL()
+ {
+ __VTPRINTENTER( "MH.ResetProto2WayL" )
+ __ASSERT_ALWAYS( iProtoState == MVtProtocolCommand::ESetup,
+ Panic( EVtEngPanicMediaHandlerOpStateFailure ) );
+
+ __VTPRINT( DEBUG_MEDIA, "MH. Calling ResetL on Proto" )
+ iUpdateVolumeAllowed = EFalse;
+ TInt cmdId = iSessionCommand->ResetProtocolL();
+ if ( cmdId > 0 )
+ {
+ // Add the operation if ok
+ AddOperation( EDestructProtoPhaseReset, cmdId, EFalse );
+ iProtoState = MVtProtocolCommand::EResetting;
+ }
+ else
+ {
+ __VTPRINT( DEBUG_MEDIA,
+ "MH.ResetProto2WayL waiting for cancel to complete" )
+ }
+ __VTPRINTEXIT( "MH.ResetProto2WayL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::SetSelectedCameraId
+// Called from Local video when camera has been selected.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::SetSelectedCameraId(
+ const TCameraId aId,
+ TBool aUpdateRequired )
+ {
+ __VTPRINTENTER( "MH.SetSelectedCameraId" )
+ __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL, "MH.SetSelectedCameraId id=%d", aId )
+ iSelectedCameraId = aId;
+ // Set flag that switch should be done later if
+ // engine has not reached proper state
+ // - but only if active provider is a camera.
+ if ( aUpdateRequired && iLocalVideo )
+ // NULL if called inside CVtEngLocalVideo::ConstructL
+ {
+ const CVtEngLocalVideo::TVtEngProviderType
+ activeProvider( iLocalVideo->ActiveProvider() );
+
+ if ( activeProvider == CVtEngLocalVideo::KVtEngProviderCam1 ||
+ activeProvider == CVtEngLocalVideo::KVtEngProviderCam2 )
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL,
+ "MH. ESourceUpdateNeeded flag set" )
+ SetFlag( ESourceUpdateNeeded );
+ }
+ }
+ __VTPRINTEXIT( "MH.SetSelectedCameraId" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::HandleLocalVideoOperationCompleteL
+// Asynchronous local video operation is completed in here.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::HandleLocalVideoOperationCompleteL(
+ const TInt aResult )
+ {
+ __VTPRINTENTER( "MH.LocVidOpComp" )
+ __VTPRINT3( DEBUG_MEDIA, "MH.LocVidOpComp res=%d,intOps=%d",
+ aResult, iPendingOps->Count() )
+ __VTPRINT2( DEBUG_MEDIA, "MH.LocVidOpComp state flags=%d", iProtoStateFlags )
+
+ // Check if video should be paused
+ if ( IsFlag( EProtoPauseVideoBlankProv ) )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.LocVidOpComp pause flagged" )
+ if ( aResult == KErrNone )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.LocVidOpComp pausing" )
+ EnableVideoL( EFalse );
+ // Not ready yet, clear the two stages and complete in the end
+ if ( IsFlag( ETwoStageOperation ) &&
+ IsFlag( EProtoContVideoBlankInit ) )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.LocVidOpComp 1 stage complete" )
+ ClearFlag( ETwoStageOperation );
+ ClearFlag( EProtoContVideoBlankInit );
+ }
+ ClearFlag( EProtoPauseVideoBlankProv );
+ }
+ }
+
+ if ( iRequestStatus )
+ {
+ if ( iVSInitState == EStateInitStillImage )
+
+ { // still image initialized, proceed to initializing blank provider
+ InitializeProviderL( *iRequestStatus );
+ __VTPRINTEXIT( "MH.LocVidOpComp" )
+ return;
+ }
+ else if ( iVSInitState == EStateInitProvider )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.LocVidOpComp reqComplete" )
+ // Part of media handler initialization
+ User::RequestComplete( iRequestStatus, aResult );
+ iRequestStatus = NULL;
+ iVSInitState = EInitStateNone;
+ __VTPRINTEXIT( "MH.LocVidOpComp" )
+ return;
+ }
+ else if ( iVSInitState == EStateWaitingProviderChangeForUninit )
+ {
+ iVSInitState = EInitStateNone;
+ iLocalVideo->StopViewFinder(); // ensure view finder is stopped
+ ContinueUninitializeL( EDestructInternals );
+ __VTPRINTEXIT( "MH.LocVidOpComp" )
+ return;
+ }
+ else if ( iVSInitState == EStateInitCanceled )
+ {
+ // If the request status has been cancelled
+ // uninitialize VT
+ ContinueUninitializeL( EDestructSwitchBlank );
+ }
+ }
+
+ // Either complete the operation or remove 2 stage flag.
+ // If flag removed, the operation will be completed when
+ // the second stage finalizes.
+ if ( IsFlag( ETwoStageOperation ) )
+ {
+ SetFlag( EProtoSendIntraFrame );
+ ClearFlag( ETwoStageOperation );
+ }
+ else
+ {
+ // Send a sync message, if video enabled.
+ if ( !IsFlag( EProtoVideoTrackPaused ) &&
+ // and
+ iInitialized &&
+ iProtoState == MVtProtocolCommand::EConnected &&
+ iPendingOp &&
+ iPendingOp->Command() == KVtEngSetSource )
+ {
+ RequestFrame();
+ }
+ // Complete operation only if it is related. We may have received
+ // KVtEngTerminateSession while prepare/set source is pending and
+ // cannot complete it!
+ if ( iPendingOp )
+ {
+ switch( iPendingOp->Command() )
+ {
+ case KVtEngHandleLayoutChange:
+ case KVtEngPrepareCamera:
+ case KVtEngSetSource:
+ case KVtEngUnfreeze:
+ CompleteOp( aResult );
+ break;
+
+ // Image sharing
+ case KVtEngInitializeShareImage:
+ __VTPRINT( DEBUG_MEDIA,
+ "MH.LocVidOpComp KVtEngInitializeShareImage" )
+ if ( aResult != KErrNone )
+ {
+ iLocalVideo->ShareError( aResult );
+ }
+ CompleteOp( aResult );
+ break;
+
+ case KVtEngStartShareImage:
+ __VTPRINT( DEBUG_MEDIA,
+ "MH.LocVidOpComp KVtEngStartShareImage" )
+ if ( aResult != KErrNone )
+ {
+ iLocalVideo->ShareError( aResult );
+ }
+ CompleteOp( aResult );
+ if ( iVideoAction == EVideoActionEnable )
+ {
+ if ( aResult == KErrNone )
+ {
+ EnableVideoL( ETrue );
+ iVideoAction = EVideoActionDisable;
+ }
+ else
+ {
+ iVideoAction = EVideoActionNone;
+ }
+ }
+
+ break;
+
+ case KVtEngStopShareImage:
+ __VTPRINT( DEBUG_MEDIA,
+ "MH.LocVidOpComp KVtEngStopShareImage" )
+ if ( aResult != KErrNone )
+ {
+ iLocalVideo->ShareError( aResult );
+ }
+ CompleteOp( aResult );
+ break;
+
+ default:
+ break;
+ }
+ }
+ }
+ __VTPRINTEXIT( "MH.LocVidOpComp" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::Disconnect
+// Starts Protocol disconnecting procedure.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::Disconnect()
+ {
+ UninitializeNextStep();
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::SdkInitInfo
+// Returns Protocol sdk initialization information.
+// -----------------------------------------------------------------------------
+//
+TVtInitInfo& CVtEngMediaHandler::SdkInitInfo()
+ {
+ return iSdkInitInfo;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::ProtoState
+// Returns protocol state, maintained by VTEngine.
+// Might be out of sync with actual Proto state.
+// -----------------------------------------------------------------------------
+//
+MVtProtocolCommand::TVtProtocolState CVtEngMediaHandler::ProtoState()
+ {
+ return iProtoState;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::Connect
+// Sets up connection with remote end.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::Connect()
+ {
+ __VTPRINTENTER( "MH.Connect" )
+ __VTPRINT( DEBUG_MEDIA, "MH.Connect" )
+ TInt err( KErrNotReady );
+ if ( ProtoState() == MVtProtocolCommand::ESetup && IsFlag( EProto324IFAcquired ) )
+ {
+ TInt cmdId( 0 );
+ __VTPRINT( DEBUG_MEDIA, "MH. Calling ConnectToProtocolL on Proto" )
+ TRAP( err, cmdId = iSessionCommand->ConnectToProtocolL( ( ( CVtEngUtility::EngineUtils() )->Initializer() ).GetVtComms() ) );
+ if ( err == KErrNone )
+ {
+ const TInt res( AddOperation( EConnectProto, cmdId) );
+ if ( res < KErrNone )
+ {
+ err = res;
+ }
+ iProtoState = MVtProtocolCommand::EConnecting;
+ __VTPRINT( DEBUG_MEDIA, "MH.protoComC: EConnecting Connecting" )
+ }
+ }
+ __VTPRINTEXITR( "MH.Connect err=%d", err )
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::AddVideoSource
+// Adds video source.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::AddVideoSource( TUint aChannelId )
+ {
+ __VTPRINTENTER( "MH.AddVideoSource" )
+
+ if( !MediaAddingValidity() )
+ return KErrCancel;
+
+ TInt cmdId( 0 );
+ TRAPD( err, cmdId = iSessionCommand->AddVideoSourceL(
+ aChannelId, *iLocalVideo->Source() ) );
+ if ( err == KErrNone )
+ {
+ const TInt res( AddOperation( EAddVideoSource, cmdId ) );
+ if ( res >= KErrNone )
+ {
+ iRemoteMediaState |= EMediaVideoPreparing;
+ }
+ else
+ {
+ err = res;
+ }
+ }
+ if ( err != KErrNone )
+ {
+ CVtEngEventManager::NotifyEvent( KVtEngMediaInitFailure );
+ }
+ __VTPRINTEXITR( "MH.AddVideoSource %d", err )
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::AddAudioSource
+// Adds audio source.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::AddAudioSource( TUint aChannelId )
+ {
+ __VTPRINTENTER( "MH.AddAudioSource" )
+
+ if( !MediaAddingValidity() )
+ return KErrCancel;
+
+ TInt cmdId( 0 );
+ TInt err( KErrNone );
+ // Only for target compilations.
+#if !defined( __WINS__ )
+ err = iLocalVideo->CreateAudioSource();
+ if ( err == KErrNone )
+ {
+ TRAP( err, cmdId = iSessionCommand->AddAudioSourceL(
+ aChannelId, *iLocalVideo->AudioSource() ) );
+ }
+#endif // !__WINS__
+#if defined (__WINS__)
+ aChannelId = aChannelId; // Remove compilation warnings with CW.
+#endif // __WINS__
+
+ if ( err == KErrNone )
+ {
+ const TInt res( AddOperation( EAddAudioSource, cmdId ) );
+ if ( res < KErrNone )
+ {
+ err = res;
+ }
+ }
+ if ( err != KErrNone )
+ {
+ CVtEngEventManager::NotifyEvent( KVtEngMediaInitFailure );
+ }
+ if ( IsFlag( ESourceUpdateNeeded ) )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.AddASource updateProvider" )
+ ClearFlag( ESourceUpdateNeeded );
+ // Generate event
+ iLocalVideo->vsProvidersChanged(
+ iSelectedCameraId == MVtEngMedia::EPrimaryCamera );
+ }
+ __VTPRINTEXITR( "MH.AddAudioSource %d", err )
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::AddVideoSinkL
+// Adds video sink.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::AddVideoSink( TUint aChannelId )
+ {
+ __VTPRINTENTER( "MH.AddVideoSink" )
+
+ if( !MediaAddingValidity() )
+ return KErrCancel;
+
+ TInt cmdId( 0 );
+ TRAPD( err, cmdId = iRemoteVideo->AddVideoSinkL( aChannelId ) );
+ if ( err == KErrNone )
+ {
+ const TInt res( AddOperation( EAddVideoSink, cmdId ) );
+ if ( res >= KErrNone )
+ {
+ iRemoteMediaState |= EMediaVideoPreparing;
+ }
+ else
+ {
+ err = res;
+ }
+ }
+ if ( err != KErrNone )
+ {
+ CVtEngEventManager::NotifyEvent( KVtEngMediaInitFailure );
+ }
+ __VTPRINTEXITR( "MH.AddVideoSink %d", err )
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::AddAudioSink
+// Adds audio sink.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::AddAudioSink( TUint aChannelId )
+ {
+ __VTPRINTENTER( "MH.AddAudioSink" )
+
+ if( !MediaAddingValidity() )
+ return KErrCancel;
+
+ TInt cmdId( 0 );
+ TRAPD( err, cmdId = iRemoteVideo->AddAudioSinkL( aChannelId ) );
+ if ( err == KErrNone )
+ {
+ const TInt res( AddOperation( EAddAudioSink, cmdId ) );
+ if ( res >= KErrNone )
+ {
+ iRemoteMediaState |= EMediaAudioPreparing;
+ }
+ else
+ {
+ err = res;
+ }
+ }
+ if ( err != KErrNone )
+ {
+ CVtEngEventManager::NotifyEvent( KVtEngMediaInitFailure );
+ }
+ __VTPRINTEXITR( "MH.AddAudioSink %d", err )
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::RemoveOperation
+// Removes an operation from stored operations.
+// -----------------------------------------------------------------------------
+//
+template<class T>
+TBool CVtEngMediaHandler::RemoveOperation( const T& aOp )
+ {
+ TBool removed( EFalse );
+ const TInt pos( IsPending( aOp ) );
+ if ( pos != KErrNotFound )
+ {
+ __VTPRINT3( DEBUG_MEDIA, "MH.RemoveOp removed index=%d TOperation=%d",
+ pos, ( *iPendingOps )[ pos ].iOp )
+ iPendingOps->Delete( pos );
+ removed = ETrue;
+ }
+ return removed;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::AddOperation
+// Adds operation to operations pending completion.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::AddOperation(
+ const TOperation aOp,
+ TInt aCmdId,
+ const TBool aResetExisting )
+ {
+ if ( aResetExisting )
+ {
+ iPendingOps->Reset();
+ }
+ TCmdOpPair opPair;
+ opPair.iOp = aOp;
+ opPair.iProtoCmdId = aCmdId;
+ // this should never leave because SetReserveL called in ConstructL
+ TRAPD( err, iPendingOps->AppendL( opPair ) );
+ if ( err != KErrNone )
+ {
+ CVtEngEventManager::NotifyEvent( KVtEngResourceMemAllocFailure );
+ return err;
+ }
+ const TInt count( iPendingOps->Count() );
+ __VTPRINT3( DEBUG_MEDIA, " MH.op added. op=%d,cmdId=%d", aOp, aCmdId )
+ __VTPRINT2( DEBUG_MEDIA, " count=%d", count )
+ return ( count - 1 );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::IsPending
+// Checks if a command is set to be completed.
+// Checking is done based on operation.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::IsPending( const TOperation aOp ) const
+ {
+ const TInt count( iPendingOps->Count() );
+ for ( TInt i = 0; i < count ; i++ )
+ {
+ if ( aOp == ( *iPendingOps )[ i ].iOp )
+ {
+ __VTPRINT2( DEBUG_MEDIA, "MH.IsPending VT Op index=%d", i )
+ return i;
+ }
+ }
+ __VTPRINT( DEBUG_MEDIA, "MH.IsPending VT Op NOT FOUND" )
+ return KErrNotFound;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::IsPending
+// Checks if a command is set to be completed.
+// Checking is done based on command id.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::IsPending( const TInt aCmdId ) const
+ {
+ const TInt count( iPendingOps->Count() );
+ for ( TInt i = 0; i < count ; i++ )
+ {
+ if ( aCmdId == ( *iPendingOps )[ i ].iProtoCmdId )
+ {
+ __VTPRINT3( DEBUG_MEDIA, "MH.IsPending ProtoCmdId=%d index=%d",
+ aCmdId, i )
+ return i;
+ }
+ }
+ __VTPRINT( DEBUG_MEDIA, "MH.IsPending ProtoCmdId NOT FOUND" )
+ return KErrNotFound;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::CompleteOp
+// Asynchronous command completion.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::CompleteOp( const TInt aResult )
+ {
+ CVtEngOperation* opToComplete = iPendingOp;
+ TInt err( KErrNotFound );
+ if ( opToComplete )
+ {
+ iPendingOp = NULL;
+ opToComplete->HandleOpComplete( aResult );
+ err = KErrNone;
+ }
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::AsyncCompleteOp
+// Asynchronous command completion.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::AsyncCompleteOp( const TInt aResult )
+ {
+ iAsyncCallback->Cancel();
+ iAsyncCompleteOpResult = aResult;
+ iAsyncCallback->Start( TCallBack( DoCompleteOp, this ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::MatchResponseToPendingOps
+// Checks if a response matches corresponding operation.
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngMediaHandler::MatchResponseToPendingOps(
+ const TInt aProtoCmdId,
+ const TOperation aOperation,
+ TInt* aIndex )
+ {
+ const TInt index( IsPending( aOperation ) );
+ TBool entryFound( EFalse );
+ if ( index != KErrNotFound )
+ {
+ const TCmdOpPair opPair = ( *iPendingOps )[index];
+ if ( opPair.iProtoCmdId == aProtoCmdId )
+ {
+ entryFound = ETrue;
+ if ( aIndex )
+ {
+ *aIndex = index;
+ }
+ }
+ }
+ __VTPRINT2( DEBUG_MEDIA, "MH.MatchRespToOp was found=%d", entryFound )
+ return entryFound;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::StartDisconnectTimerL
+// Starts the disconnect timer.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::StartDisconnectTimerL()
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH. start disc.timer" )
+ if ( iTimer == NULL )
+ {
+ TCallBack cb( CVtEngMediaHandler::TimerCallback, NULL );
+ iTimer = CPeriodic::NewL( 0 );
+ iTimer->Start( KVtEngDisconnectionTimer,
+ KVtEngDisconnectionTimer,
+ cb );
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::NextUninitStepCallbackL
+// Proceeds to next uninitializatioin step asynchronously.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::NextUninitStepCallbackL()
+ {
+ __VTPRINTENTER( "MH.NextUninitStepCallbackL" )
+ if ( !iNextStepCallback )
+ {
+ // perform asap => high priority
+ TCallBack cb( CVtEngMediaHandler::UninitCallback, this );
+ iNextStepCallback = new ( ELeave ) CAsyncCallBack(
+ cb, CActive::EPriorityHigh );
+ iNextStepCallback->CallBack();
+ }
+ __VTPRINTEXIT( "MH.NextUninitStepCallbackL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::UninitCallback
+// Asynch callback method for uninitialization.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::UninitCallback( TAny* aAny )
+ {
+ __VTPRINTENTER( "MH.UninitCallback" )
+ CVtEngMediaHandler* handler = static_cast<CVtEngMediaHandler*>( aAny );
+ delete handler->iNextStepCallback;
+ handler->iNextStepCallback = NULL;
+ handler->UninitializeNextStep();
+ __VTPRINTEXIT( "MH.UninitCallback" )
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::AssignPendingOp
+// Assigns operation and completes pending if necessary.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::AssignPendingOp(
+ CVtEngOperation& aOperation,
+ TInt aReplaceError )
+ {
+ TInt result = KErrNone;
+ if ( iPendingOp )
+ {
+ if ( aReplaceError != KErrNone &&
+ // if terminating don't allow other commands
+ iPendingOp->Command() != KVtEngTerminateSession )
+ {
+ __VTPRINT2( DEBUG_MEDIA, "MH.Assign op replace err=", aReplaceError )
+ CompleteOp( aReplaceError );
+ // indicate previous operation was "cancelled" (even though it is
+ // not really cancelled, we still get callback!)
+ result = KErrCancel;
+ }
+ else
+ {
+ // not allowed to assign new operation
+ result = KErrGeneral;
+ }
+ }
+ if ( result != KErrGeneral )
+ {
+ __VTPRINT2( DEBUG_MEDIA, "MH.AssignPendingOp=%d", aOperation.Command() )
+ iPendingOp = &aOperation;
+ }
+ __VTPRINT2( DEBUG_MEDIA, "MH.AssignPendingOp.res=%d", result )
+ return result;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::DoCompleteOp
+// Implementation of command completion.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::DoCompleteOp( TAny* aAny )
+ {
+ CVtEngMediaHandler* self = static_cast< CVtEngMediaHandler* >( aAny );
+ self->CompleteOp( self->iAsyncCompleteOpResult );
+ self->iAsyncCompleteOpResult = KErrNone;
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::GetPendingCommand
+//
+// -----------------------------------------------------------------------------
+//
+TVtEngCommandId CVtEngMediaHandler::GetPendingCommand()
+ {
+ if ( iPendingOp )
+ {
+ return iPendingOp->Command();
+ }
+ return KVtEngCommandNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::AssertFlag
+// Checks flag's validity.
+// -----------------------------------------------------------------------------
+//
+#ifdef _DEBUG
+void CVtEngMediaHandler::AssertFlag( const TInt aFlag ) const
+#else
+void CVtEngMediaHandler::AssertFlag( const TInt /* aFlag */ ) const
+#endif // _DEBUG
+ {
+ __ASSERT_DEBUG(
+ aFlag == EProtoAudioSourceAdded ||
+ aFlag == EProtoVideoSourceAdded ||
+ aFlag == EProtoAudioSinkAdded ||
+ aFlag == EProtoVideoSinkAdded ||
+ aFlag == EProtoAudioTrackPaused ||
+ aFlag == EProtoVideoTrackPaused ||
+ aFlag == ETwoStageOperation ||
+ aFlag == EProtoPauseVideoRequested ||
+ aFlag == EProtoPauseVideoBlankProv ||
+ aFlag == EProtoContVideoBlankProv ||
+ aFlag == EProtoContVideoBlankInit ||
+ aFlag == ESourceUpdateNeeded ||
+ aFlag == EProtoSendIntraFrame ||
+ aFlag == EProto324IFAcquired ||
+ aFlag == EProtoCancelProtoCmdsOk ||
+ aFlag == EVideoQualitySetByPeer ||
+ aFlag == EOutVideoChannelClosed ||
+ aFlag == EOutAudioChannelClosed,
+ Panic( EVtEngPanicInvalidFlag ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::IsFlag
+// Checks if a certain flag is set.
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngMediaHandler::IsFlag( const TInt aFlag ) const
+ {
+ AssertFlag( aFlag );
+ if ( iProtoStateFlags & aFlag )
+ {
+ return ETrue;
+ }
+ else
+ {
+ return EFalse;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::SetFlag
+// Sets flag on.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::SetFlag( const TInt aFlag )
+ {
+ AssertFlag( aFlag );
+ iProtoStateFlags |= aFlag;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::ClearFlag
+// Removes a flag.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::ClearFlag( const TInt aFlag )
+ {
+ AssertFlag( aFlag );
+ iProtoStateFlags &= ~aFlag;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::SetVolume
+// Sets volume values to Protocol.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::SetVolume(
+ const TInt aVolume,
+ CVtEngOperation* aOperation )
+ {
+ __VTPRINTENTER( "MH.SetVolume" )
+ TInt res( KErrNotFound );
+ __VTPRINT2( DEBUG_MEDIA, " vol=%d", aVolume )
+ if ( iAudioCtrl )
+ {
+ TInt id( 0 );
+ // Max volume cannot be zero.
+ TInt vol( ( CVtEngUtility::Settings().ValidVolume( aVolume ) ) *
+ ( iProtoMaxVolume / CVtEngUtility::Settings().MaxVolume() ) );
+ __VTPRINT2( DEBUG_MEDIA, "CVtEngMediaHandler::SetVolumeL, vol=%d", vol )
+ TRAP( res, id = iAudioCtrl->SetAudioVolumeL( vol ) );
+ if ( res == KErrNone )
+ {
+ AddOperation( ESetAudioVolume, id );
+ if( aOperation )
+ {
+ AssignPendingOp( *aOperation );
+ }
+ }
+ }
+ __VTPRINTEXITR( "MH.SetVolume %d", res )
+ return res;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::RequestAudioControllerL
+// Requests controllers for audio output and input
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngMediaHandler::RequestAudioControllerL()
+ {
+ __VTPRINTENTER( "MH.RequestAudioControllerL" )
+ __VTPRINT( DEBUG_MEDIA, "MH.RequestAudioControllerL" )
+ __ASSERT_ALWAYS(iSessionCommand, Panic( EVtEngPanicInvalidAudioPointer ) );
+
+ TInt id( 0 );
+ iAudioCtrl = VTProtocolFactory::GetAudioConfigCommandL(iRemoteVideo->AudioSink());
+
+ if ( !iAudioCtrl )
+ {
+ CVtEngEventManager::NotifyEvent( KVtEngMediaInitFailure );
+ __VTPRINTEXIT( "MH.RequestAudioControllerL Failed" )
+ return EFalse;
+ }
+ iAudioCtrl->SetObserverL( this );
+
+ // Get the max value for Protocol volume
+ TRAPD ( res, id = iAudioCtrl->GetMaxAudioVolumeL( iProtoMaxVolume ) ) ;
+ __VTPRINT2( DEBUG_MEDIA, "MH.RequestAudioControllerL: err=%d",res )
+ if ( res != KErrNone)
+ {
+ CVtEngEventManager::NotifyEvent( KVtEngMediaInitFailure );
+ __VTPRINTEXIT( "MH.RequestAudioControllerL" )
+ return EFalse;
+ }
+
+ res = AddOperation( EGetAudioGetMaxVolume, id );
+ if ( res < KErrNone ) // res is index
+ {
+ CVtEngEventManager::NotifyEvent( KVtEngMediaInitFailure );
+ __VTPRINT2( DEBUG_MEDIA, "MH.RequestAudioControllerL::res=%d", res )
+ }
+ __VTPRINTEXIT( "MH.RequestAudioControllerL" )
+ return ETrue;
+ }
+
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::HandleSpatialTradeoffIndication
+//
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::HandleSpatialTradeoffIndication(
+ const TUint16 aLogicalChannelId, const TUint8 aTradeOff )
+ {
+ __VTPRINTENTER( "MH.HandleSpatialTradeoffIndication" )
+ __VTPRINT3( DEBUG_MEDIA,
+ "MH.HandleSpatialTradeoffIndication id=%d tradeOff=%d",
+ aLogicalChannelId, aTradeOff )
+ ( void ) aLogicalChannelId;
+ iVideoQuality.UpdateVideoQuality( iVideoQuality.FromTradeOff( aTradeOff ) );
+ __VTPRINTEXIT( "MH.HandleSpatialTradeoffIndication" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::HandleSpatialTradeoffCommandL
+//
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::HandleSpatialTradeoffCommandL(
+ const TUint16, const TUint8 aTradeOff )
+ {
+ __VTPRINTENTER( "MH.HandleSpatialTradeoffCommandL" )
+ SetVideoQualityL( iVideoQuality.FromTradeOff( aTradeOff ), EFalse );
+ __VTPRINTEXIT( "MH.HandleSpatialTradeoffCommandL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::EnableVideoL
+// Enables/Disables video sending.
+// -----------------------------------------------------------------------------
+//
+CVtEngMediaHandler::TOperation CVtEngMediaHandler::EnableVideoL(
+ const TBool aEnable, const TOperation aOp )
+ {
+ __VTPRINTENTER( "MH.EnableVideoL" )
+ __VTPRINT3( DEBUG_MEDIA | DEBUG_DETAIL, "MH.EnableV en=%d state=%d",
+ aEnable, iProtoState )
+ TInt cmdId( 0 );
+ TInt err( KErrNone );
+ TOperation op( ENone );
+ MVtEngMedia::TMediaSource currentSource;
+ GetSource( currentSource );
+
+ // Videosource is added and Protocol is in connected state.
+ if ( IsFlag( EProtoVideoSourceAdded ) && iSessionCommand )
+ {
+ __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL, "MH.EnableV source=%d",
+ currentSource )
+ // Has an actual source been selected.
+ if ( ( currentSource == EMediaNone ) || ( currentSource == EMediaShare ) )
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "MH.EnaLocVideo blank" )
+ if ( aEnable && IsPending( EEnableVideo) == KErrNotFound )
+ {
+ ClearFlag( EProtoPauseVideoRequested );
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "MH. Calling ResumeL on Protocol" )
+ TRAP( err, cmdId = iSessionCommand->ResumeVideoL( *iLocalVideo->Source() ) );
+ if ( err != KErrNone )
+ {
+ // Log the error and leave, UI handles the rest
+ __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL,
+ "MH.EnaLocVideo PauseL left=%d", err )
+ __VTPRINTEXIT( "MH.EnableVideoL" )
+ User::Leave( err );
+ }
+ else
+ {
+ op = aOp;
+ AddOperation( aOp, cmdId );
+ }
+ }
+ // Video to be paused.
+ else if( !aEnable && IsPending( EDisableVideo ) )
+ {
+ op = DoPauseVideo();
+ }
+ }
+ else // camera or still image
+ {
+ if ( !aEnable && IsPending( EDisableVideo ) )
+ {
+ // Pause video
+ op = DoPauseVideo();
+ }
+ }
+ }
+ else // Not connected and sources not added yet
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "MH.enavideo not conn" )
+ // If we are initializing, then this has to be executed
+ if ( IsFlag( EProtoContVideoBlankProv ) )
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "MH.enavideo blank cont" )
+ ClearFlag( EProtoContVideoBlankProv );
+ SetFlag( EProtoContVideoBlankInit );
+ }
+
+ if ( aEnable )
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "MH.EnableV clear pending" )
+ // Ensure that video sending is enabled in data source.
+ iLocalVideo->ResumeVideoSending();
+ ClearFlag( EProtoPauseVideoRequested );
+ }
+ else
+ {
+ iLocalVideo->PauseVideoSending();
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL, "MH.EnableV set pending" )
+ SetFlag( EProtoPauseVideoRequested );
+ }
+ }
+
+ __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL, "MH.EnableV=%d", err )
+ __VTPRINTEXITR( "MH.EnableVideoL %d", op )
+ return op;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::DoPauseVideo
+// Does video pausing.
+// -----------------------------------------------------------------------------
+//
+CVtEngMediaHandler::TOperation CVtEngMediaHandler::DoPauseVideo()
+ {
+ __VTPRINTENTER( "MH.DoPauseVideo" )
+ TInt cmdId( 0 );
+ TOperation op( ENone );
+ __VTPRINT( DEBUG_MEDIA, "MH. Calling PauseL on Protocol" )
+ TRAPD( err, cmdId = iSessionCommand->PauseVideoL( *iLocalVideo->Source() ) );
+ if ( err != KErrNone )
+ {
+ __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL,
+ "MH.DoPauseVideo PauseL left=%d", err )
+ // Remove the 2 stage flag, since PauseL failed.
+ // Command should be completed.
+ if( IsFlag( ETwoStageOperation ) )
+ {
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL,
+ " Disable 2 stage clearance" )
+ ClearFlag( ETwoStageOperation );
+ }
+ }
+ else
+ {
+ AddOperation( EDisableVideo, cmdId );
+ op = EDisableVideo;
+ __VTPRINT( DEBUG_MEDIA | DEBUG_DETAIL,
+ "MH.DisaLocVideo PauseL issued" )
+ }
+ ClearFlag( EProtoPauseVideoRequested );
+ __VTPRINTEXITR( "MH.DoPauseVideo %d", op )
+ return op;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::HandleAudioOutputControlCommandComplete
+// Callback function for audio controller commands.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::HandleAudioOutputControlCommandComplete(TInt aId,
+ TVtAudioOutputControlCommand aCmd,
+ TAny* /*aContextData*/,
+ TInt aStatus)
+ {
+ __VTPRINTENTER( "MH.HandleAudioOutputControlCommandComplete" )
+ __VTPRINT2( DEBUG_MEDIA, "MH.AudioComC CMD=%d", aCmd )
+ __VTPRINT2( DEBUG_MEDIA, "MH.AudioComC cmdId=%d", aId )
+ __VTPRINT2( DEBUG_MEDIA, "MH.AudioComC stat=%d", aStatus )
+
+ switch ( aCmd )
+ {
+ case EVtAudioOutputControlGetMaxVolume:
+ RemoveOperation( aId );
+ InitializeVolume();
+ break;
+ case EVtAudioOutputControlSetVolume:
+ __VTPRINT2( DEBUG_MEDIA, "MH.protoComC SetVolume=%d",
+ iUpdateVolumeRequired )
+
+ RemoveOperation( aId );
+
+ if ( iUpdateVolumeRequired )
+ {
+ iUpdateVolumeRequired = EFalse;
+ UpdateVolume();
+ }
+
+ if ( IsPending( ESetAudioVolume ) == KErrNotFound &&
+ iPendingOp == iPendingVolumeOp )
+ {
+ iPendingVolumeOp = NULL;
+ CompleteOp( aStatus );
+ }
+ break;
+ case EVtAudioOutputControlGetBalance:
+ case EVtAudioOutputControlSetBalance:
+ case EVtAudioOutputControlGetVolume:
+ default:
+ break;
+ }
+ __VTPRINTEXIT( "MH.HandleAudioOutputControlCommandComplete" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::InitializeVolume
+// Sets the 'beginning' values for volume.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::InitializeVolume()
+ {
+ __VTPRINT2( DEBUG_MEDIA, "MH.InitializeVolume: max vol=%d", iProtoMaxVolume )
+ iUpdateVolumeAllowed = ETrue;
+ UpdateVolume();
+ if ( iLocalVideo )
+ {
+ iLocalVideo->UnMute();
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::DisconnectProtoL
+// Does the disconnecting of Protocol.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::DisconnectProtoL()
+ {
+ __VTPRINTENTER( "MH.DisconnectProtoL" )
+ __VTPRINT2( DEBUG_MEDIA, "MH.DisconnectProto with Protocol state=%d",
+ iProtoState )
+ TInt cmdId( 0 );
+ // The two states that require disconnecting
+ if ( iProtoState == MVtProtocolCommand::EConnected ||
+ iProtoState == MVtProtocolCommand::EConnecting )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH. Calling DisconnectFromProtocolL on Protocol" )
+ TRAPD( err, cmdId = iSessionCommand->DisconnectFromProtocolL() );
+ if ( err == KErrNone )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.protoCom: Disconnecting" )
+ AddOperation( EDestructProtoPhaseDisconnect, cmdId );
+ iProtoState = MVtProtocolCommand::EDisconnecting;
+ StartDisconnectTimerL();
+ }
+ else
+ {
+ // Canceling the disconnect to notify that it has failed
+ __VTPRINT2( DEBUG_MEDIA, "MH.DisconnectProto erronous=%d", err )
+ cmdId = err;
+ }
+ }
+ else {
+ cmdId = KErrNotSupported;
+ }
+ __VTPRINTEXITR( "MH.DisconnectProtoL cmdId=%d", cmdId )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::CancelAllProtoCommands
+// Cancels all commands pending for execution in Proto.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::CancelAllProtoCommands( TOperation &aOp )
+ {
+ __VTPRINTENTER( "MH.CancelAllProtoCommands" )
+ TInt err( KErrNotReady );
+ aOp = ENone;
+ if ( IsPending( EUninitializeCancelAllProto ) != KErrNotFound )
+ {
+ aOp = EUninitializeCancelAllProto;
+ // Indicate difference from started cancellation with error code.
+ err = KErrAlreadyExists;
+ }
+ else if ( iSessionCommand && iPendingOps && !IsFlag( EProtoCancelProtoCmdsOk ) )
+ {
+ if ( iPendingOps->Count() )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH. Calling CancelAllCommandsL on Proto" )
+ TInt cmdId( 0 );
+ TRAP( err, ( cmdId = iSessionCommand->CancelAllCommandsL() ) );
+ __VTPRINT2( DEBUG_MEDIA | DEBUG_DETAIL,
+ "MH.CancelAllProtoCommands cmdId=%d", cmdId )
+ if ( cmdId && err == KErrNone )
+ {
+ aOp = EUninitializeCancelAllProto;
+ SetFlag( EProtoCancelProtoCmdsOk );
+ AddOperation( aOp, cmdId );
+ }
+ // completes in CommandCompletedL
+ }
+ else {
+ // mark there's nothing to cancel
+ SetFlag( EProtoCancelProtoCmdsOk );
+ }
+ }
+ __VTPRINTEXITR( "MH.CancelAllProtoCommands err=%d", err )
+ return err;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::ProtoInitialized
+// Proto init completed.
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngMediaHandler::ProtoInitialized() const
+ {
+ return iSessionCommand ? ETrue : EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::TimerCallback
+// Callback method for timer expiration.
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::TimerCallback( TAny* /*aAny*/ )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.TimerCallback -> PANIC " )
+ Panic( EVtEngPanicDisconnectTimerExpired );
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::SetVersionInfoL
+// Sets version information to Proto.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::SetVersionInfoL( )
+ {
+ __VTPRINTENTER( "MH.SetVersionInfoL" )
+
+ if ( !iH324Config )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.SetVersion not ready" )
+ User::Leave( KErrNotReady );
+ }
+
+ // Current new line character index
+ TInt index( 0 );
+
+ // Version information from SysUtil
+ HBufC* versionInfo16 = HBufC::NewLC( KVtEngSwVersionTextLength );
+
+ // Pointer to SysUtil versionInfo descriptor. Temporary pointer to
+ // handle data.
+ TPtr versionInfoptr16( versionInfo16->Des() );
+
+ // SW Version and product information buffers to be send to peer.
+ HBufC8* version = HBufC8::NewLC( KVtEngSwVersionTextLength );
+ HBufC8* product = HBufC8::NewLC( KVtEngSwVersionTextLength );
+ TPtr8 versionPtr8( version->Des() );
+ TPtr8 productPtr8( product->Des() );
+
+ // Marker for line ending '\n'
+ const TChar endLine( KVtEngCharacterEndLine );
+
+ TInt err = ( SysUtil::GetSWVersion( versionInfoptr16 ) );
+ if ( err != KErrNone || !versionInfoptr16.Length() )
+ {
+ __VTPRINT2( DEBUG_MEDIA, "MH.SetVersion SU: %d", err )
+ __VTPRINTEXIT( "MH.SetVersionInfoL" )
+ return;
+ }
+#ifdef VTDEBUG
+ RDebug::Print( _L("SysUtil::GetSWVersion: %s"), versionInfoptr16.Ptr() );
+#endif
+ // Construct similar buffer than for version information and get po
+ HBufC* productInfo16 = versionInfo16->AllocLC();
+ TPtr productInfoptr16( productInfo16->Des() );
+
+ // We assume that format from file is:
+ // SW version\ndate\nproduct\nmanufacturer
+ // \n is new line character
+
+ // Find first new line character
+ index = versionInfo16->Locate( endLine );
+ if ( index >= 0 )
+ {
+ // Replace new line character using space.
+ versionInfoptr16[ index ] = KVtEngCharacterSpace ;
+
+ // Find second new line character, this ends the version information
+ index = versionInfo16->Locate( endLine );
+ if ( index >= 0 )
+ {
+ // Take version information and ignore product info.
+ versionInfoptr16 = versionInfo16->Left( index );
+
+ // Take product information and ignore version information.
+ productInfoptr16 = productInfo16->Mid( index + 1 );
+
+ // Find the only remaining new line character.
+ index = productInfoptr16.Locate( endLine );
+
+ // Replace new line character using space.
+ productInfoptr16[ index ] = KVtEngCharacterSpace;
+
+ // Copy 16 bit descriptors to 8 bit descriptors and append
+ // zero terminators.
+ versionPtr8.Copy( versionInfoptr16 );
+ versionPtr8.ZeroTerminate();
+ productPtr8.Copy( productInfoptr16 );
+ productPtr8.ZeroTerminate();
+
+ // Set the info to Protocol
+#ifdef VTDEBUG
+ RDebug::Print(_L("MH.Product: %s" ), productPtr8.Ptr() );
+ RDebug::Print(_L("MH.Version: %s" ), versionPtr8.Ptr() );
+#endif //VTDEBUG
+
+ AddOperation( ESetVendorId,
+ iH324Config->SetVendorId( KVtEngCountryCodeForProto,
+ KVtEngExtensionForProto,
+ KVtEngManufacturerForProto, &productPtr8, &versionPtr8 ) );
+ }
+ }
+ CleanupStack::PopAndDestroy( 4 ); // HBufC's
+ __VTPRINTEXIT( "MH.SetVersionInfoL" )
+ }
+
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::RequestFrame
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::RequestFrame( )
+ {
+ __VTPRINTENTER( "MH.RequestFrame" )
+ if ( !iH263Encoder )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.RequestFrame FAILED")
+ return;
+ }
+ AddOperation( ESendIntraframe,iH263Encoder->RequestNextIntraFrame() );
+ ClearFlag( EProtoSendIntraFrame );
+
+ __VTPRINTEXIT( "MH.RequestFrame" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::SetVideoQualityL
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::SetVideoQualityL(
+ const TVideoQuality aVideoQuality, const TBool aSetPeerVideoQuality )
+ {
+ __VTPRINTENTER( "MH.SetVideoQualityL" )
+ if ( !iH263Encoder )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.SetVideoQualityL FAILED")
+ return;
+ }
+ SetFlag( EVideoQualitySetByPeer );
+ TInt protoOperId( iH263Encoder->SetVideoFrameRate(
+ iVideoQuality.ToFrameRate( aVideoQuality ) ) );
+ AddOperation( ESetVideoQuality, protoOperId );
+ iVideoQuality.SettingVideoQuality( protoOperId,
+ aVideoQuality, aSetPeerVideoQuality );
+ __VTPRINTEXIT( "MH.SetVideoQualityL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::SetPeerVideoQuality
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::SetPeerVideoQuality( const TVideoQuality aVideoQuality )
+ {
+ __VTPRINTENTER( "MH.SetPeerVideoQuality" )
+ AddOperation( ESendVTSTO, iH324Config->SendVideoTemporalSpatialTradeoffCommand(
+ iVideoIncomingLogicalChannel.iLogicalChannelId,
+ iVideoQuality.ToTradeOff( aVideoQuality ) ) );
+ __VTPRINTEXIT( "MH.SetPeerVideoQuality" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::HandleVideoEncoderCommandCompletedL
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::HandleVideoEncoderCommandCompletedL(
+ const TVtCommandResponse& aResponse )
+ {
+ __VTPRINTENTER( "MH.EncExtCommandCompleted" )
+ const TInt type( aResponse.iCmdType );
+ const TInt protoCmdId( aResponse.iCmdId );
+ const TInt protoResponse( aResponse.iCmdStatus );
+ __VTPRINT2( DEBUG_MEDIA, "MH.263 ComC type=%d", type )
+ __VTPRINT3( DEBUG_MEDIA, "MH.263 ComC cmdId=%d,response=%d",
+ protoCmdId, protoResponse )
+
+ // Find correct entry in iPendingOps based on TOperation because there can
+ // be several entries with same Protocol cmd id since each Protocol interface has their
+ // own id allocation and ids may overlap.
+ TInt index( KErrNotFound );
+ TOperation completedOp = ENone;
+ if ( MatchResponseToPendingOps( protoCmdId, ESendIntraframe, &index ) ||
+ MatchResponseToPendingOps( protoCmdId, ESetIFrameInterval, &index ) ||
+ MatchResponseToPendingOps( protoCmdId, ESetVideoQuality, &index ) )
+ {
+ // TOperation entries in are unique in the array...
+ const TCmdOpPair pair = (*iPendingOps)[ index ];
+ completedOp = pair.iOp;
+ // ...so remove based on that instead of protoCmdId
+ RemoveOperation( completedOp );
+ }
+ else
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.EECC ERROR (response to unknown command)" )
+ }
+ if ( completedOp == ESetVideoQuality )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.EECC ESetVideoQuality" )
+ if( iPendingOp && ( iPendingOp->Command() == KVtEngSetVideoQuality ) )
+ {
+ CompleteOp( protoResponse );
+ }
+ if( protoResponse == KErrNone )
+ {
+ TVtEngVideoQuality::TVQSParams vqp;
+
+ if ( iVideoQuality.SettingSucceeded( protoCmdId, vqp ) )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.EECC sending vq indication" )
+ AddOperation( ESendVTSTO,
+ iH324Config->SendVideoTemporalSpatialTradeoffIndication(
+ iVideoOutgoingLogicalChannel.iLogicalChannelId,
+ iVideoQuality.ToTradeOff( vqp.iValue ) ) );
+ if ( vqp.iSetPeer )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.EECC setting peer vq" )
+ SetPeerVideoQuality( vqp.iValue );
+ }
+ }
+ }
+ else
+ {
+ iVideoQuality.SettingFailed( protoCmdId );
+ }
+ }
+ if ( iProtoState == MVtProtocolCommand::EIdle )
+ { // Command was complete during uninitialization.
+ NextUninitStepCallbackL();
+ }
+ __VTPRINTEXIT( "MH.EncExtCommandCompleted" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::HandleVideoEncoderInformationalEventL
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::HandleVideoEncoderInformationalEventL(
+ const TVtIndicationEvent& aEvent)
+ {
+ const TInt type( aEvent.iEventType );
+ __VTPRINT2( DEBUG_MEDIA, "MH.263 infoevent=%d", type )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::HandleH324MConfigCommandCompletedL
+//
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::HandleH324MConfigCommandCompletedL(
+ const TVtCommandResponse& aResponse )
+ {
+ __VTPRINTENTER( "MH.HandleH324MConfigCommandCompletedL" )
+ const TInt protoCmdId( aResponse.iCmdId );
+ const TInt protoResponse( aResponse.iCmdStatus );
+ const TInt type( aResponse.iCmdType );
+
+ __VTPRINT2( DEBUG_MEDIA, "MH.HandleH324MConfigCommandCompletedL type=%d", type )
+ __VTPRINT3( DEBUG_MEDIA, "MH.HandleH324MConfigCommandCompletedL cmdId=%d,response=%d", protoCmdId, protoResponse )
+ TInt index( KErrNotFound );
+ // Find correct entry in iPendingOps based on TOperation because there can
+ // be several entries with same Protocol cmd id since each Protocol interface has their
+ // own id allocation and ids may overlap.
+ if ( MatchResponseToPendingOps( protoCmdId, ESetVendorId, &index ) ||
+ MatchResponseToPendingOps( protoCmdId, ESendVTSTO, &index ) ||
+ MatchResponseToPendingOps( protoCmdId, ESetSupportedResolutions, &index ) ||
+ MatchResponseToPendingOps( protoCmdId, ESetFastCsupOptions, &index ) )
+ {
+ // TOperation entries in are unique in the array...
+ const TCmdOpPair pair = (*iPendingOps)[ index ];
+ // ...so remove based on that instead of protoCmdId
+ RemoveOperation( pair.iOp );
+ }
+ switch( iProtoState )
+ {
+ case MVtProtocolCommand::EConnected:
+ {
+ CVtEngStateManager* stateManager = CVtEngUtility::StateManager();
+
+ // Check does the received command ID match to command ID that was received
+ // from Protocol when DTMF was send.
+ if( stateManager->Handlers().Dtmf().CheckCommandId( protoCmdId ) )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.Complete DTMF" )
+ stateManager->Handlers().Dtmf().SendComplete( protoResponse );
+ }
+ }
+ break;
+ case MVtProtocolCommand::EIdle: // extension command complete
+ NextUninitStepCallbackL();
+ default:
+ break;
+ }
+
+ __VTPRINTEXITR( "MH.HandleH324MConfigCommandCompletedL.CommandID %d", aResponse.iCmdId )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::HandleH324MConfigInformationalEventL
+//
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::HandleH324MConfigInformationalEventL(
+ const TVtIndicationEvent& aEvent )
+ {
+ __VTPRINTENTER( "MH.HandleH324MConfigInformationalEventL" )
+
+ const TInt type( aEvent.iEventType );
+ const TUint8* buffer = (const_cast<TVtIndicationEvent&>(aEvent)).iLocalBuffer;
+
+ switch(type)
+ {
+ case EVtIndicationVideoSpatialTamporalTradeOffIndication:
+ case EVtIndicationVideoSpatialTamporalTradeOffCommand:
+ {
+ TUint16 logicalChannelId = BigEndian::Get16( buffer );
+ TUint8 tradeOffValue = buffer[ 2 ];
+ __VTPRINT3( DEBUG_MEDIA, "MH.protoHIE.H324 channelId=%d, tradeOff=%d",
+ logicalChannelId, tradeOffValue )
+ if( type ==
+ EVtIndicationVideoSpatialTamporalTradeOffIndication )
+ {
+ HandleSpatialTradeoffIndication( logicalChannelId,
+ tradeOffValue );
+ }
+ else
+ {
+ HandleSpatialTradeoffCommandL( logicalChannelId,
+ tradeOffValue );
+ }
+ }
+ break;
+
+ // When remote terminal sends its UII capabilities in TCS we get
+ // indication from Protocol. If remote does not send UII capas in TCS
+ // we are obliged to use alphanumeric UIIs as specified by 245
+ // spec. Default is IA5String.We get bit pattern from Protocol but
+ // they are listed below in preferred order of usage.
+ // The order can be freely chosen.
+ case EVtIndicationUserInputCapability:
+ {
+#ifdef VTDEBUG
+ RDebug::Print(_L("Buffer[0]:%d"), buffer[0] );
+#endif // VTDEBUG
+ __VTPRINT( DEBUG_MEDIA,
+ "MH.protoHIE UserInput Capability Indication" )
+
+ CVtEngStateManager* stateManager =
+ CVtEngUtility::StateManager();
+
+ // IA5String preferred, it's the simplest and most used in TCSs.
+ if ( buffer[0] & CVtEngDtmfHandler::EIA5String )
+ {
+ stateManager->Handlers().Dtmf().SetUIISupport(
+ CVtEngDtmfHandler::EIA5String );
+ CVtEngEventManager::NotifyEvent(
+ KVtEngRemoteUIIIA5StringSupport );
+ __VTPRINT( DEBUG_MEDIA,
+ "KVtEngRemoteUIIIA5StringSupport Support signalled" )
+ }
+ // Basic string is also simple and easy to use, second position.
+ else if ( buffer[0] & CVtEngDtmfHandler::EBasicString )
+ {
+ stateManager->Handlers().Dtmf().SetUIISupport(
+ CVtEngDtmfHandler::EBasicString );
+ CVtEngEventManager::NotifyEvent(
+ KVtEngRemoteUIIBasicStringSupport );
+ __VTPRINT( DEBUG_MEDIA,
+ "KVtEngRemoteUIIBasicStringSupport Support signalled" )
+ }
+ // DTMFs are more limited but more interoperable than
+ // General string.
+ else if ( buffer[0] & CVtEngDtmfHandler::EDTMFString )
+ {
+ stateManager->Handlers().Dtmf().SetUIISupport(
+ CVtEngDtmfHandler::EDTMFString );
+ CVtEngEventManager::NotifyEvent( KVtEngRemoteUIIDtmfSupport );
+ __VTPRINT( DEBUG_MEDIA,
+ "KVtEngRemoteUIIDtmfSupport Support signalled" )
+ }
+ // General string is the complicated one, priority is
+ // lowest because of possible diffuculties in remote
+ // end decoding of string (various number of letter
+ // combinations).
+ else if ( buffer[0] & CVtEngDtmfHandler::EGeneralString )
+ {
+ stateManager->Handlers().Dtmf().SetUIISupport(
+ CVtEngDtmfHandler::EGeneralString );
+ CVtEngEventManager::NotifyEvent(
+ KVtEngRemoteUIIGeneralStringSupport );
+ __VTPRINT( DEBUG_MEDIA,
+ "KVtEngRemoteUIIGeneralStringSupport Support signalled" )
+ }
+ else
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.HIE invalid DTMF" )
+ Panic( EVtEngPanicInvalidDtmfState );
+ }
+ }
+ break;
+ }
+ __VTPRINTEXIT( "MH.HandleH324MConfigInformationalEventL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::SetSupportedResolutionsL
+// Sets supported resolutions to protocol.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::SetSupportedResolutions()
+ {
+ __VTPRINTENTER( "MH.SetSupportedResolutions" )
+ __ASSERT_ALWAYS( iH324Config != NULL, Panic( EVtEngPanicInvalidPointer ) );
+
+ AddOperation( ESetSupportedResolutions,
+ iH324Config->SetSupportedResolutions( ) );
+ __VTPRINTEXIT( "MH.SetSupportedResolutions " )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::SetFastCsupOptions
+// Sets supported resolutions to Protocol.
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::SetFastCsupOptions()
+ {
+ __VTPRINTENTER( "MH.SetFastCsupOptions" )
+
+ AddOperation(
+ ESetFastCsupOptions,
+ iH324Config->SetFastCsupOptions( ) );
+ __VTPRINTEXIT( "MH.SetFastCsupOptions" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::CreateExtensionsL
+// Creates extension according to API Uid.
+// -----------------------------------------------------------------------------
+//
+CVtEngExtensionBase* CVtEngMediaHandler::CreateExtensionsL( const TUid& aUid )
+ {
+ __VTPRINTENTER( "MH.CreateExtensionsL" )
+
+ // if UID is supported camera pref
+ if ( aUid == KVtEngExtensionCameraPreferences )
+ {
+ __VTPRINT2( DEBUG_GEN, "MH.CreateExtensionsL extension UID=%d",
+ aUid.iUid )
+
+ CVtEngExtensionBase* base = reinterpret_cast< CVtEngExtensionBase* >
+ ( iLocalVideo->CreateCameraPreferencesL() );
+ __VTPRINTEXITR( "MH.CreateExtensionsL base [%d]", ( TInt )base )
+ return base;
+ }
+
+#if defined ( RD_VT_RTF )
+
+ // if UID is supported R2F
+ else if ( aUid == KVtEngExtensionRecord2File )
+ {
+ CVtEngExtensionBase* base = reinterpret_cast< CVtEngExtensionBase* >
+ ( CVtEngRecord2File::NewL() );
+ __VTPRINTEXITR( "MH.CreateExtensionsL base [%d]", ( TInt )base )
+ return base;
+ }
+ // not supported UID
+
+#endif //RD_VT_RTF
+
+ else
+ {
+ __VTPRINTEXITR( "MH.CreateExtensionsL error [%d]", KErrNotSupported )
+ User::Leave( KErrNotSupported);
+ return NULL;
+ }
+ }
+
+// Implementation for TVtEngVideoQuality
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::TVtEngVideoQuality::TVtEngVideoQuality
+// -----------------------------------------------------------------------------
+//
+CVtEngMediaHandler::TVtEngVideoQuality::TVtEngVideoQuality()
+ : iCurrent( EVideoQualityNormal ), iParamList( 1 )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::TVtEngVideoQuality::~TVtEngVideoQuality
+// -----------------------------------------------------------------------------
+//
+CVtEngMediaHandler::TVtEngVideoQuality::~TVtEngVideoQuality()
+ {
+ iParamList.Reset();
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::TVtEngVideoQuality::SettingVideoQuality
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::TVtEngVideoQuality::SettingVideoQuality(
+ TInt aId, const TVideoQuality aValue, TBool aSetPeer )
+ {
+ __VTPRINTENTER( "MH.VQ.SettingVideoQuality" )
+ iParamList.Append( TVQSParams( aId, aValue, aSetPeer ) );
+ __VTPRINTEXIT( "MH.VQ.SettingVideoQuality" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::TVtEngVideoQuality::VideoQuality
+// -----------------------------------------------------------------------------
+//
+MVtEngMedia::TVideoQuality
+ CVtEngMediaHandler::TVtEngVideoQuality::VideoQuality() const
+ {
+ __VTPRINTENTER( "MH.VQ.VideoQuality" )
+ __VTPRINTEXITR( "MH.VQ.VideoQuality %d", iCurrent )
+ return iCurrent;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::TVtEngVideoQuality::IsSetPeer
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngMediaHandler::TVtEngVideoQuality::SettingSucceeded( TInt aId,
+ TVQSParams& aParams )
+ {
+ __VTPRINTENTER( "MH.VQ.SettingSucceeded" )
+ TInt index( FindVQSParam( aId ) );
+ TBool foundRecord( index != KErrNotFound );
+ if ( foundRecord )
+ {
+ aParams = iParamList[ index ];
+ iParamList.Remove( index );
+ iParamList.Compress();
+ }
+ __VTPRINTEXITR( "MH.VQ.SettingSucceeded %d", foundRecord )
+ return foundRecord;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::TVtEngVideoQuality::IsSetPeer
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::TVtEngVideoQuality::UpdateVideoQuality(
+ const TVideoQuality aVideoQuality )
+ {
+ __VTPRINTENTER( "MH.VQ.UpdateVideoQuality" )
+ iCurrent = aVideoQuality;
+ __VTPRINTEXIT( "MH.VQ.UpdateVideoQuality" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::TVtEngVideoQuality::SettingFailed
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::TVtEngVideoQuality::SettingFailed( TInt aId )
+ {
+ __VTPRINTENTER( "MH.VQ.SettingFailed" )
+ TInt index( FindVQSParam( aId ) );
+ if ( index != KErrNotFound )
+ {
+ iParamList.Remove( index );
+ iParamList.Compress();
+ }
+ __VTPRINTEXITR( "MH.VQ.SettingFailed %d", index )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::TVtEngVideoQuality::FromTradeOff
+// -----------------------------------------------------------------------------
+//
+MVtEngMedia::TVideoQuality
+ CVtEngMediaHandler::TVtEngVideoQuality::FromTradeOff(
+ const TInt aTradeOff ) const
+ {
+ __VTPRINTENTER( "MH.VQ.FromTradeOff" )
+ TVideoQuality videoQuality;
+
+ // [0 .. KVtEngTradeOffDetailMax]
+ if( aTradeOff <= KVtEngTradeOffDetailMax )
+ {
+ videoQuality = EVideoQualityDetail;
+ }
+ // ]KVtEngTradeOffDetailMax .. KVtEngTradeOffNormalMax]
+ else if( aTradeOff <= KVtEngTradeOffNormalMax )
+ {
+ videoQuality = EVideoQualityNormal;
+ }
+ // ]KVtEngTradeOffNormalMax .. 31]
+ else
+ {
+ videoQuality = EVideoQualityMotion;
+ }
+ __VTPRINTEXITR( "MH.VQ.FromTradeOff %d", videoQuality )
+ return videoQuality;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::TVtEngVideoQuality::ToFrameRate
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::TVtEngVideoQuality::ToFrameRate(
+ const TVideoQuality aVideoQuality ) const
+ {
+ __VTPRINTENTER( "MH.VQ.ToFrameRate" )
+ TInt frameRate( 0 );
+ CVtEngSettings& settings = CVtEngUtility::Settings();
+ switch( aVideoQuality )
+ {
+ case EVideoQualityDetail:
+ frameRate = settings.VideoQualityFrameRateConfig().iDetail;
+ break;
+
+ case EVideoQualityNormal:
+ frameRate = settings.VideoQualityFrameRateConfig().iNormal;
+ break;
+
+ case EVideoQualityMotion:
+ frameRate = settings.VideoQualityFrameRateConfig().iMotion;
+ break;
+
+ default:
+ Panic( EVtEngPanicInvalidVideoQualityValue );
+ break;
+ }
+ __VTPRINTEXITR( "MH.VQ.ToFrameRate %d", frameRate )
+ return frameRate;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::TVtEngVideoQuality::ToTradeOff
+// -----------------------------------------------------------------------------
+//
+TUint8 CVtEngMediaHandler::TVtEngVideoQuality::ToTradeOff(
+ const TVideoQuality aVideoQuality ) const
+ {
+ __VTPRINTENTER( "MH.VQ.ToTradeOff" )
+ TUint8 tradeOff( 0 );
+ switch( aVideoQuality )
+ {
+ case EVideoQualityDetail:
+ tradeOff = KVtEngTradeOffDetailMax;
+ break;
+
+ case EVideoQualityNormal:
+ tradeOff = KVtEngTradeOffNormalMax;
+ break;
+
+ case EVideoQualityMotion:
+ tradeOff = KVtEngTradeOffMotionMax;
+ break;
+
+ default:
+ Panic( EVtEngPanicInvalidVideoQualityValue );
+ break;
+ }
+ __VTPRINTEXITR( "MH.VQ.ToTradeOff %d", tradeOff )
+ return tradeOff;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::TVtEngVideoQuality::FindVQSParam
+// -----------------------------------------------------------------------------
+//
+TInt CVtEngMediaHandler::TVtEngVideoQuality::FindVQSParam( TInt aId ) const
+ {
+ __VTPRINTENTER( "MH.VQ.FindVQSParam" )
+ TInt result( KErrNotFound );
+ for ( TInt i = iParamList.Count() - 1; i >= 0; i-- )
+ {
+ if ( iParamList[ i ].iId == aId )
+ {
+ result = i;
+ break;
+ }
+ }
+ __VTPRINTEXITR( "MH.VQ.FindVQSParam %d", result )
+ return result;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::TVtEngVideoQuality::TVQSParams::TVQSParams
+// -----------------------------------------------------------------------------
+//
+CVtEngMediaHandler::TVtEngVideoQuality::TVQSParams::TVQSParams()
+ {
+ Mem::FillZ( this, sizeof( TVQSParams ) );
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::TVtEngVideoQuality::TVQSParams::TVQSParams
+// -----------------------------------------------------------------------------
+//
+CVtEngMediaHandler::TVtEngVideoQuality::TVQSParams::TVQSParams(
+ TInt aId, const TVideoQuality aValue, TBool aSetPeer )
+ : iId( aId ), iValue( aValue ), iSetPeer( aSetPeer )
+ {
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::QueryProtoInterfacesL
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::QueryProtoInterfacesL()
+ {
+ __VTPRINTENTER( "MH.QueryProtoInterfacesL" )
+ // Ensure call is still connected to prevent unnecessary Protocol
+ // interface acquisition
+ CVtEngStateManager* states = CVtEngUtility::StateManager();
+ const MVtEngSessionInfo::TSessionState sessionState =
+ states->SessionState();
+ if ( sessionState != MVtEngSessionInfo::EIdle &&
+ sessionState != MVtEngSessionInfo::EClearing )
+
+ {
+ // Request the 324M Stack interface
+ if ( !IsFlag( EProto324IFAcquired ) )
+ {
+ /*
+ AddOperation( EGet324CtrlInterface,
+ iSessionCommand->GetProtocolInterfaceL(
+ EVtH324Config,
+ ( MVtProtocolCommand*& ) iH324Config ));
+ */
+ MVtProtocolCommand *pCommand = NULL;
+ AddOperation( EGet324CtrlInterface,
+ iSessionCommand->GetProtocolInterfaceL(
+ EVtH324Config,
+ ( MVtProtocolCommand*& ) pCommand ));
+ iH324Config = static_cast<MVtH324ConfigCommand *>(pCommand);
+ }
+ // Get encoder interface.
+ /*
+ AddOperation( EGetH263EncInterface,
+ iSessionCommand->GetProtocolInterfaceL(
+ EVtVideoEncoderConfig,
+ ( MVtProtocolCommand*& ) iH263Encoder ));
+ */
+ MVtProtocolCommand *pCommand = NULL;
+ AddOperation( EGetH263EncInterface,
+ iSessionCommand->GetProtocolInterfaceL(
+ EVtVideoEncoderConfig,
+ ( MVtProtocolCommand*& ) pCommand ));
+ iH263Encoder = static_cast<MVtVideoConfigCommand *>(pCommand);
+ }
+ __VTPRINTEXIT( "MH.QueryProtoInterfacesL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::ReleaseProtoInterfacesL
+// -----------------------------------------------------------------------------
+//
+void CVtEngMediaHandler::ReleaseProtoInterfacesL()
+ {
+ __VTPRINTENTER( "MH.ReleaseProtoInterfacesL" )
+
+ // Release interfaces
+ __VTPRINT( DEBUG_MEDIA, "LCN: MH.324 started to release interfaces" )
+ if( iH324Config )
+ {
+ /*
+ AddOperation( ERemove324CtrlInterface,
+ iSessionCommand->DeleteProtocolInterfaceL( EVtH324Config, iH324Config ) );*/
+ MVtProtocolCommand *pCommand = NULL;
+ pCommand = static_cast<MVtProtocolCommand *>(iH324Config);
+ AddOperation( ERemove324CtrlInterface,
+ iSessionCommand->DeleteProtocolInterfaceL( EVtH324Config, pCommand ) );
+ iH324Config = 0;
+ __VTPRINT( DEBUG_MEDIA, "MH.324 started to release" )
+ }
+
+ if ( iH263Encoder )
+ {
+ /*
+ AddOperation( ERemoveH263EncInterface,
+ iSessionCommand->DeleteProtocolInterfaceL( EVtVideoEncoderConfig, iH263Encoder ) );*/
+ MVtProtocolCommand *pCommand = NULL;
+ pCommand = static_cast<MVtProtocolCommand *>(iH263Encoder);
+ AddOperation( ERemoveH263EncInterface,
+ iSessionCommand->DeleteProtocolInterfaceL( EVtVideoEncoderConfig, pCommand ) );
+ iH263Encoder = 0;
+ iH263Encoder = 0;
+ __VTPRINT( DEBUG_MEDIA, "MH.263 started to release" )
+ }
+ __VTPRINTEXIT( "MH.ReleaseProtoInterfacesL" )
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::ExtensionCommandsPending
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngMediaHandler::ExtensionCommandsPending() const
+ {
+ __VTPRINTENTER( "MH.ExtensionCommandsPending" )
+ TBool isPending = EFalse;
+ TInt count( iPendingOps->Count() );
+ while ( count-- )
+ {
+ const TOperation op = ( *iPendingOps )[ count ].iOp;
+ switch ( op )
+ {
+ // extension commands
+ case ESendIntraframe:
+ case ESetSupportedResolutions:
+ case ESetVideoQuality:
+ case ESendVTSTO:
+ case ESetFastCsupOptions:
+ case ESetVendorId:
+ case ESetIFrameInterval:
+ isPending = ETrue;
+#ifdef _DEBUG
+ RDebug::Print( _L(" (ext) op=%d,protoCmdId=%d"),
+ op, ( *iPendingOps )[ count ].iProtoCmdId );
+#else
+// in debug mode allow printing all pending ops to log
+ count = 0; // break loop
+#endif
+ break;
+ default:
+ break;
+ }
+ }
+ __VTPRINTEXITR( "MH.ExtensionCommandsPending %d", isPending )
+ return isPending;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::MediaAddingValidity
+// -----------------------------------------------------------------------------
+//
+TBool CVtEngMediaHandler::MediaAddingValidity() const
+ {
+ __VTPRINTENTER( "MH.MediaAddingValidity" )
+
+ TBool addingOK( ETrue );
+ CVtEngStateManager* states = CVtEngUtility::StateManager();
+ MVtEngSessionInfo::TSessionState sessionState ( states->SessionState() );
+ if( sessionState == MVtEngSessionInfo::EClearing ||
+ sessionState == MVtEngSessionInfo::EIdle )
+ {
+ __VTPRINT( DEBUG_MEDIA, "MH.MediaAddingValidity NOT ALLOWED" )
+ // State is wrong, adding not allowed.
+ addingOK = EFalse;
+ }
+
+ __VTPRINTEXITR( "MH.MediaAddingValidity %d", addingOK )
+
+ return addingOK;
+ }
+
+// -----------------------------------------------------------------------------
+// CVtEngMediaHandler::CancelInitializeShareImage
+// -----------------------------------------------------------------------------
+void CVtEngMediaHandler::CancelInitializeShareImage()
+ {
+ __VTPRINTENTER( "CVtEngMediaHandler.CancelInitializeShareImage");
+ if(iLocalVideo)
+ {
+ iLocalVideo->CancelInitializeShareImage();
+ }
+ __VTPRINTEXIT( "CVtEngMediaHandler.CancelInitializeShareImage");
+ }
+
+// End of File