/*

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