/*

* Copyright (c) 2005 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: 

*

*/

// USER

#include "musenglivesession.h"

#include "musengsessionobserver.h"

#include "musenglivesessionobserver.h"

#include "musunittesting.h"

#include "musengmceutils.h"

#include "musenglogger.h"

#include "mussettings.h"

// SYSTEM

#include <mcemanager.h>

#include <mcecamerasource.h>

#include <mcevideostream.h>

#include <mcertpsink.h>

#include <mcedisplaysink.h>

#include <mcefilesink.h>

#include <mcesession.h>

#include <mcevideocodec.h>

#include <mceh263codec.h>

#include <mceavccodec.h>

const TInt KMaxBrightness = 100;

const TInt KMinBrightness = -100;

const TInt KBrightnessStepSize = 10;

// Names of AVC levels in string for config keys stored in CenRep 

_LIT8( KMusAvcBitrateLevel1, "AvcBrL1=" );

_LIT8( KMusAvcBitrateLevel1b, "AvcBrL1b=" );

_LIT8( KMusAvcBitrateLevel1_1, "AvcBrL1_1=" );

_LIT8( KMusAvcBitrateLevel1_2, "AvcBrL1_2=" );

_LIT8( KMusAvcBitrateLevel1_3, "AvcBrL1_3=" );

_LIT8( KMusAvcBitrateLevel2, "AvcBrL2=" );

_LIT8( KMusEncoderInfoTokenizer, ";" );

//Number of big and small zoom steps on Zoom scale

const TInt KZoomBigStepCount = 15;

const TInt KZoomSmallStepCount = KZoomBigStepCount*2;

const TInt KZoomStepMinSize = 1;

const TInt64 KZoomFasterTime = 333333; // 1/3 second

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

//

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

//

EXPORT_C CMusEngLiveSession* CMusEngLiveSession::NewL(

                        const TDesC& aFileName,

                        const TRect& aRect,

                        MMusEngSessionObserver& aSessionObserver,

                        MMusEngOutSessionObserver& aOutSessionObserver,

                        MMusEngLiveSessionObserver& aLiveSessionObserver,

                        TUint aSipProfileId )

    {

    CMusEngLiveSession* self = new( ELeave ) CMusEngLiveSession( 

                                                    aSessionObserver,

                                                    aOutSessionObserver,

                                                    aLiveSessionObserver, 

                                                    aRect,

                                                    aFileName );

    CleanupStack::PushL( self );

    self->ConstructL( aSipProfileId );

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

EXPORT_C CMusEngLiveSession* CMusEngLiveSession::NewL(

                        const TRect& aRect,

                        MMusEngSessionObserver& aSessionObserver,

                        MMusEngOutSessionObserver& aOutSessionObserver,

                        MMusEngLiveSessionObserver& aLiveSessionObserver,

                        TUint aSipProfileId )

    {

    CMusEngLiveSession* self = new( ELeave ) CMusEngLiveSession( 

                                                    aSessionObserver,

                                                    aOutSessionObserver,

                                                    aLiveSessionObserver, 

                                                    aRect );

    CleanupStack::PushL( self );

    self->ConstructL( aSipProfileId );

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

CMusEngLiveSession::~CMusEngLiveSession()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngLiveSession::~CMusEngLiveSession()" )

    MUS_LOG( "mus: [ENGINE]  <- CMusEngLiveSession::~CMusEngLiveSession()" )

    }

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

//

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

//

EXPORT_C TInt CMusEngLiveSession::CurrentZoomL() const

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngLiveSession::CurrentZoomL()" )

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *iSession );

    TInt currentZoom = camera->ZoomFactorL() + camera->DigitalZoomFactorL();

    MUS_LOG1( "mus: [ENGINE]  <- CMusEngLiveSession::CurrentZoomL( %d )",

              currentZoom )

    return currentZoom;

    }

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

//

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

//

EXPORT_C void CMusEngLiveSession::SetZoomL( TInt aNewZoomFactor )

    {

    MUS_LOG1( "mus: [ENGINE]  -> CMusEngLiveSession::SetZoomL( %d )", 

              aNewZoomFactor )

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    __ASSERT_ALWAYS( aNewZoomFactor <= MaxZoomL() &&

                     aNewZoomFactor >= MinZoomL(), 

                     User::Leave( KErrArgument ) );

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *iSession );

        {

        MUS_LOG( "mus: [ENGINE]     Optical zoom factor increased" )

        camera->SetZoomFactorL( aNewZoomFactor ); 

        }

        {

        camera->SetDigitalZoomFactorL( aNewZoomFactor - iCameraInfo.iMaxZoom );

        MUS_LOG1( "mus: [ENGINE]     Digital zoom factor increased to %d",

                  aNewZoomFactor - iCameraInfo.iMaxZoom )

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngLiveSession::SetZoomL()" )

    }

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

//

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

//

EXPORT_C TInt CMusEngLiveSession::MinZoomL() const

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngLiveSession::MinZoomL()" )

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    // Although we do not need camera for return value, we have to have it in

    // order to have proper iCameraInfo

    MusEngMceUtils::GetCameraL( *iSession );

    MUS_LOG1( "mus: [ENGINE]  <- CMusEngLiveSession::MinZoomL( %d )",

              iCameraInfo.iMinZoom )

    return iCameraInfo.iMinZoom;

    }

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

//

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

//

EXPORT_C TInt CMusEngLiveSession::MaxZoomL() const

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngLiveSession::MaxZoomL()" )

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    // Although we do not need camera for return value, we have to have it in

    // order to have proper iCameraInfo

    MusEngMceUtils::GetCameraL( *iSession );

    TInt maxZoom = iCameraInfo.iMaxZoom + iCameraInfo.iMaxDigitalZoom;

    MUS_LOG1( "mus: [ENGINE]     Max optical zoom( %d )",

              iCameraInfo.iMaxZoom )

    MUS_LOG1( "mus: [ENGINE]     Max digital zoom( %d )",

              iCameraInfo.iMaxDigitalZoom )

    MUS_LOG1( "mus: [ENGINE]  <- CMusEngLiveSession::MaxZoomL( %d )",

              maxZoom )

    return maxZoom;

    }

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

//

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

//

EXPORT_C void CMusEngLiveSession::ZoomInL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngLiveSession::ZoomInL()" )

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *iSession );

    // First try to increase optical zoom factor. If in maximum value, try to

    // increase digital zoom factor.

    TInt stepSize = ZoomStepSize( iZoomInTime );

    TInt zoomFactor = camera->ZoomFactorL();

    TInt zoomDigitalFactor = camera->DigitalZoomFactorL();

    //increate optical zoom factor

    if ( zoomFactor + stepSize <= iCameraInfo.iMaxZoom )

        {

        //optical zoom factor is enough

        camera->SetZoomFactorL( zoomFactor + stepSize );

        stepSize = 0;

        }

    else if (zoomFactor <  iCameraInfo.iMaxZoom)

       {

            stepSize -=  iCameraInfo.iMaxZoom - zoomFactor;

            camera->SetZoomFactorL( iCameraInfo.iMaxZoom );

       }

    //increate digital zoom factor

    if (stepSize > 0)

        {

        if ( zoomDigitalFactor + stepSize <= iCameraInfo.iMaxDigitalZoom )

            {

            camera->SetDigitalZoomFactorL( zoomDigitalFactor + stepSize );

            }

        else 

            {

            camera->SetDigitalZoomFactorL( iCameraInfo.iMaxDigitalZoom );

            MUS_LOG( "mus: [ENGINE]     CMusEngLiveSession::ZoomInL(): Optical \

                             and digital zoom factors are in maximum value" )

            }

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngLiveSession::ZoomInL()" )

    }

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

//

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

//

EXPORT_C void CMusEngLiveSession::ZoomOutL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngLiveSession::ZoomOutL()" )

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *iSession );

    // First try to decrease digital zoom factor. If already zero, try to

    // decrease optical zoom factor.

    TInt stepSize = ZoomStepSize( iZoomOutTime );

    TInt zoomFactor = camera->ZoomFactorL();

    TInt zoomDigitalFactor = camera->DigitalZoomFactorL();

    //decreate digital zoom factor firstly

    if ( zoomDigitalFactor - stepSize >= 0  )

        {

        //digital zoom factor is enough

        camera->SetDigitalZoomFactorL( zoomDigitalFactor - stepSize );

        stepSize = 0;

        }

    else if ( zoomDigitalFactor > 0 )

        {

        stepSize -= zoomDigitalFactor;

        camera->SetDigitalZoomFactorL( 0 );

        MUS_LOG("mus: [ENGINE] Digigal Factor to zero")

        }

    //decreate optical zoom factor firstly

    if ( stepSize > 0 )

        {

        if ( zoomFactor - stepSize > iCameraInfo.iMinZoom )

            {

            camera->SetZoomFactorL( zoomFactor - stepSize );

            }

        else 

            {

            MUS_LOG( "mus: [ENGINE]    CMusEngLiveSession::ZoomOutL(): Optical and \

                        digital zoom factors are in minimum value" )

            camera->SetZoomFactorL( iCameraInfo.iMinZoom );

            }

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngLiveSession::ZoomOutL()" )

    }

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

//

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

//

EXPORT_C void CMusEngLiveSession::ZoomDefaultL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngLiveSession::ZoomDefaultL()" )

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *iSession );

    camera->SetZoomFactorL( iDefaultZoomFactor );

    camera->SetDigitalZoomFactorL( 0 );

    MUS_LOG( "mus: [ENGINE]  <- CMusEngLiveSession::ZoomDefaultL()" )

    }

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

//

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

//

EXPORT_C void CMusEngLiveSession::SetBrightnessL( TInt aBrightness ) const

    {

    MUS_LOG1( "mus: [ENGINE]  -> CMusEngLiveSession::SetBrightnessL( %d )",

              aBrightness )

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *iSession );

    camera->SetBrightnessL( aBrightness );

    MUS_LOG( "mus: [ENGINE]  <- CMusEngLiveSession::SetBrightnessL()" )

    }

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

//

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

//

EXPORT_C TInt CMusEngLiveSession::CurrentBrightnessL() const

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngLiveSession::CurrentBrightnessL()" )

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *iSession );

    TInt currentBrightness = camera->BrightnessL();

    MUS_LOG1( "mus: [ENGINE]  <- CMusEngLiveSession::CurrentBrightnessL(): %d",

              currentBrightness )

    return currentBrightness;

    }

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

//

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

//

EXPORT_C TInt CMusEngLiveSession::MaxBrightnessL() const

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngLiveSession::MaxBrightnessL()" )

    // maximum brightness is not in camera info, but a constant 100

    MUS_LOG1( "mus: [ENGINE]  <- CMusEngLiveSession::MaxBrightnessL(): %d",

              KMaxBrightness )

    return KMaxBrightness;

    }

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

//

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

//

EXPORT_C TInt CMusEngLiveSession::MinBrightnessL() const

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngLiveSession::MinBrightnessL()" )

    // maximum brightness is not in camera info, but a constant -100

    MUS_LOG1( "mus: [ENGINE]  <- CMusEngLiveSession::MinBrightnessL(): %d",

              KMinBrightness )

    return KMinBrightness;

    }

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

//

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

//

EXPORT_C void CMusEngLiveSession::IncreaseBrightnessL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngLiveSession::IncreaseBrightnessL()" )

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *iSession );

    TInt newBrightness = camera->BrightnessL() + KBrightnessStepSize;

    if ( newBrightness < KMaxBrightness )

        {

        camera->SetBrightnessL( newBrightness );

        }

    else

        {

        camera->SetBrightnessL( KMaxBrightness );

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngLiveSession::IncreaseBrightnessL()" )

    }

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

//

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

//

EXPORT_C void CMusEngLiveSession::DecreaseBrightnessL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngLiveSession::DecreaseBrightnessL()" )

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *iSession );

    TInt newBrightness = camera->BrightnessL() - KBrightnessStepSize;

    if ( newBrightness > KMinBrightness )

        {

        camera->SetBrightnessL( newBrightness );

        }

    else

        {

        camera->SetBrightnessL( KMinBrightness );

        }

    MUS_LOG( "mus: [ENGINE]  <- CMusEngLiveSession::DecreaseBrightnessL()" )

    }

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

//

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

//

EXPORT_C void CMusEngLiveSession::BrightnessDefaultL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngLiveSession::BrightnessDefaultL()" )

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *iSession );

    camera->SetBrightnessL( iDefaultBrightness );

    MUS_LOG( "mus: [ENGINE]  <- CMusEngLiveSession::BrightnessDefaultL()" )

    }

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

//

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

//

EXPORT_C void CMusEngLiveSession::BrightnessAutoL()

    {

    MUS_LOG( "mus: [ENGINE]  -> CMusEngLiveSession::BrightnessAutoL()" )

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    CMceCameraSource* camera = MusEngMceUtils::GetCameraL( *iSession );

    camera->SetBrightnessL( CCamera::EBrightnessAuto );

    MUS_LOG( "mus: [ENGINE]  <- CMusEngLiveSession::BrightnessAutoL()" )

    }

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

//

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

//

EXPORT_C void CMusEngLiveSession::RecordL( TBool aRecord )

    {

    MUS_LOG1( "mus: [ENGINE]  -> CMusEngLiveSession::RecordL( %d )", aRecord )    

    __ASSERT_ALWAYS( iSession, User::Leave( KErrNotReady ) );

    CMceMediaSink* fileSink = MusEngMceUtils::GetMediaSink( *iSession, 

                                                            KMceFileSink );

    __ASSERT_ALWAYS( fileSink, User::Leave( KErrNotReady ) );

    if( aRecord && !fileSink->IsEnabled() )

        {

        fileSink->EnableL();        

        }

    else if ( !aRecord && fileSink->IsEnabled() )

        {

        fileSink->DisableL();        

        }

    else

        {

        // NOP

        }

    MUS_LOG1( "mus: [ENGINE]  <- CMusEngLiveSession::RecordL( %d )", aRecord ) 

    }    

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