/*

* Copyright (c) 2006 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:  Video Source subsystem.

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <bautils.h>

#include <imageconversion.h>

#include <cvtimageconverter.h>

#include <RPhCltServer.h>

#include <CPhCltImageHandler.h>

#include <w32std.h>

#include "CVSStillImageDataProvider.h"

#include "CVSDataSourceImp.h"

#include "VSPanic.h"

#include "cvtimagebitmap.h"

#include "CVSMMFDataBuffer.h"

#include "cmultiframeprovider.h"

// EXTERNAL FUNCTION PROTOTYPES

// MACROS

#ifdef _DEBUG

#    define __IF_DEBUG(t) {RDebug::t;}

#else

#    define __IF_DEBUG(t)

#endif

// LOCAL CONSTANTS AND MACROS

static const TInt KMinZoom = 0;

static const TInt KMaxZoom = 0;

static const TInt KMaxDigitalZoom = 0;

static const TReal32 KMinZoomFactor = 0.0;

static const TReal32 KMaxZoomFactor = 0.0;

static const TReal32 KMaxDigitalZoomFactor = 1.0;

static const TInt KNumVideoSizesSupported = 1;

static const TInt KNumVideoFrameSizesSupported = 1;

static const TInt KNumVideoFrameRatesSupported = 1;

static const TInt KMaxFramesPerBufferSupported = 1;

static const TInt KQcifWidth = 176;

static const TInt KQcifHeight = 144;

static const TReal32 KFrameRate = 15.0;

static const TUint32 KVSViewFinderUpdateRate = 1000000/15; // 15 times per second

// TYPE DEFINITIONS

// Timer expired callback

typedef void (CVSStillImageDataProvider::*TTimerElapsed) ();

// INTERNAL CLASSES

/**

*  Timer class that calls given callback method when timer request has been

*  completed. If the timer request is cancelled then callback will not be

*  called.

*

*  @lib videosource.lib

*/

class CVSFrameRateTimer : public CTimer

    {

    public: // Constructors and destructor

        /**

        * Static factory function to create instance of this class.

        * @param "aRequester" ?description

        * @exception Can leave with one of the system wide error codes.

        * @return Pointer to new instance.

        */

        static CVSFrameRateTimer* NewL( CVSStillImageDataProvider* aRequester );

    public: // New functions

    public: // Functions from base classes

        /**

        * Starts timer request. When timer request has been completed given

        * callback method will be called.

        * @param "anInterval" Interval after which event is to occur,

        * in microseconds.

        * @param "aFunction" Callback method that will be called when timer

        * request has been completed.

        */

        void After(

            TTimeIntervalMicroSeconds32 anInterval,

            TTimerElapsed aFunction  );

    public: // Constructors and destructor

        /**

        * Destructor.

        */

        ~CVSFrameRateTimer();

    protected:  // New functions

    protected:  // Functions from base classes

    private:    // Constructors and destrcutor

        /**

        * Constructor.

        * @param "aRequester" ?description

        */

        CVSFrameRateTimer( CVSStillImageDataProvider* aRequester );

    private:    // New functions

    private:    // Functions from base classes

        /**

        * From CActive. See CActive for description.

        */

        void RunL();

    public: // Data

    protected:  // Data

    private:    // Data

        // Pointer to requester (i.e. through which callback call will be made)

        CVSStillImageDataProvider* iRequester; // not owned

        // Pointer to callback method.

        TTimerElapsed iFunction;

    };

// ============================ MEMBER FUNCTIONS ===============================

// ============================ CVSFrameRateTimer ==============================

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

// CVSFrameRateTimer::NewL( CVSStillImageDataProvider* aRequester )

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

//

CVSFrameRateTimer* CVSFrameRateTimer::NewL(

    CVSStillImageDataProvider* aRequester )

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::NewL() >>"), RThread().Id().operator TUint()));

    CVSFrameRateTimer* self = new (ELeave) CVSFrameRateTimer( aRequester );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); // self

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::NewL() <<"), RThread().Id().operator TUint()));

    return self;

    }

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

// CVSFrameRateTimer::CVSFrameRateTimer( CVSStillImageDataProvider* aRequester )

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

//

CVSFrameRateTimer::CVSFrameRateTimer( CVSStillImageDataProvider* aRequester )

: CTimer( EPriorityStandard ), iRequester( aRequester )

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::CVSFrameRateTimer() >>"), RThread().Id().operator TUint()));

    // Added to CActiveScheduler in CVSStillImageDataProvider::InitializeL

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::CVSFrameRateTimer() <<"), RThread().Id().operator TUint()));

    }

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

// CVSFrameRateTimer::After(

//  TTimeIntervalMicroSeconds32 anInterval, TTimerElapsed aFunction )

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

//

void CVSFrameRateTimer::After(

    TTimeIntervalMicroSeconds32 anInterval,

    TTimerElapsed aFunction )

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::After() >>"), RThread().Id().operator TUint()));

    if ( iFunction == aFunction )

    	{

    	if ( !IsActive() )

    		{

      	iFunction = aFunction;

    		CTimer::After( anInterval );

    		}

    	}

    else

    	{

    	if ( !IsActive() )

    		{

      	iFunction = aFunction;

    		CTimer::After( anInterval );

    		}

    	else

    		{

    			User::Panic(_L("VideoSource"),KErrGeneral);

    		}

    	}

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::After() <<"), RThread().Id().operator TUint()));

    }

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

// CVSFrameRateTimer::~CVSFrameRateTimer()

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

//

CVSFrameRateTimer::~CVSFrameRateTimer()

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::~CVSFrameRateTimer() >>"), RThread().Id().operator TUint()));

    Cancel();

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::~CVSFrameRateTimer() <<"), RThread().Id().operator TUint()));

    }

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

// CVSFrameRateTimer::RunL()

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

//

void CVSFrameRateTimer::RunL()

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::RunL() >>"), RThread().Id().operator TUint()));

    if( iStatus.Int() == KErrNone )

        {

        (iRequester->*iFunction)();

        }

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSFrameRateTimer::RunL() <<"), RThread().Id().operator TUint()));

    }

// ============================ CVSStillImageDataProvider ===============================

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

// CVSStillImageDataProvider::NewL(

//  MVSDataProviderObserver* aObserver, MVSBufferPool* aPool )

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

//

CVSStillImageDataProvider* CVSStillImageDataProvider::NewL(

    MVSDataProviderObserver* aObserver,

    MVSBufferPool* aPool )

    {

    __IF_DEBUG(Print(_L("VideoSource: [%d] CVSStillImageDataProvider::NewL() >>"), RThread().Id().operator TUint()));

    CVSStillImageDataProvider* self =

    new (ELeave) CVSStillImageDataProvider( aObserver, aPool );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    __IF_DEBUG(Print(_L("VideoSource: [%d] CVSStillImageDataProvider::NewL() <<"), RThread().Id().operator TUint()));

    return self;

    }

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

// CVSStillImageDataProvider::~CVSStillImageDataProvider()

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

//

CVSStillImageDataProvider::~CVSStillImageDataProvider()

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::~CVSStillImageDataProvider() this %x >>"), RThread().Id().operator TUint(), this));

    iFs.Close();

    delete iVFTimer;

    delete iActiveWait;

    delete iViewer;

    iFreezeCS.Close();

    delete iScaled;

    ReleaseYUVData();

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::~CVSStillImageDataProvider() this %x <<"), RThread().Id().operator TUint(), this));

    }

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

// CVSStillImageDataProvider::InitializeL( const TDesC8& aInitParams )

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

//

void CVSStillImageDataProvider::InitializeL( const TDesC8& aInitParams )

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::InitializeL() >>"), RThread().Id().operator TUint()));

    CommonInitializeL();

    TPckgBuf< TVSStillImageDataProviderParams > pb;

    pb.Copy( aInitParams );

    iInitType = pb().iInitialize;

    iPSState = EPSInitializing;

    switch( pb().iInitialize )

        {

        /** Initialize from blank image */

        case TVSStillImageDataProviderParams::EInitializeAsBlankImage:

            BlankImageInitializeL();

            break;

        /** Initialize from General Settings */

        case TVSStillImageDataProviderParams::EInitializeFromGeneralSettings:

            GeneralSettingsInitializeL( EGSStillImage );

            break;

        /** Initilaize from General Settings*/

        case TVSStillImageDataProviderParams::EInitializeAsDefaultStillImage:

            GeneralSettingsInitializeL( EGSDefaultStillImage );

            break;

        /** Initialize from file */

        case TVSStillImageDataProviderParams::EInitializeFromFile:

            FileImageInitializeL( pb().iFileName );

            break;

        }

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::InitializeL() <<"), RThread().Id().operator TUint()));

    }

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

// CVSStillImageDataProvider::CommonInitializeL()

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

//

void CVSStillImageDataProvider::CommonInitializeL()

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::CommonInitializeL() >>"), RThread().Id().operator TUint()));

    iVFTimer = CVSFrameRateTimer::NewL( this );

    CActiveScheduler::Add( iVFTimer );

    iActiveWait = new (ELeave) CVSActiveWait< CVSStillImageDataProvider > ( this );

    //Create viewer

    User::LeaveIfError( iFreezeCS.CreateLocal() );

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::CommonInitializeL() <<"), RThread().Id().operator TUint()));

    }

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

// CVSStillImageDataProvider::GeneralSettingsInitializeL()

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

//

void CVSStillImageDataProvider::GeneralSettingsInitializeL( const TGeneralSettingsImageType aType )

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::GeneralSettingsInitializeL() >>"), RThread().Id().operator TUint()));

		iViewer->IniatializeGSL( aType );

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::GeneralSettingsInitializeL() <<"), RThread().Id().operator TUint()));

    }

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

// CVSStillImageDataProvider::BlankImageInitializeL()

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

//

void CVSStillImageDataProvider::BlankImageInitializeL()

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::BlankImageInitializeL() %x >>"), RThread().Id().operator TUint(), this));

		iViewer->IniatializeBlankL();

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::BlankImageInitializeL() %x <<"), RThread().Id().operator TUint(), this));

    }

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

// CVSStillImageDataProvider::FileImageInitializeL

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

//

void CVSStillImageDataProvider::FileImageInitializeL( const TFileName& aFileName )

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::FileImageInitializeL(): %S >>"), RThread().Id().operator TUint(), &aFileName ));

		iViewer->InitializeL( &aFileName );

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::FileImageInitializeL() %x <<"), RThread().Id().operator TUint(), this));

    }

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

// CVSStillImageDataProvider::DigitalZoomFactor() const

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

//

TInt CVSStillImageDataProvider::DigitalZoomFactor() const

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::DigitalZoomFactor() >>"), RThread().Id().operator TUint()));

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::DigitalZoomFactor() <<"), RThread().Id().operator TUint()));

    return KMaxDigitalZoom;

    }

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

// CVSStillImageDataProvider::SetDigitalZoomFactorL(

//  TInt /*aDigitalZoomFactor*/ )

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

//

void CVSStillImageDataProvider::SetDigitalZoomFactorL(

    TInt /*aDigitalZoomFactor*/ )

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SetDigitalZoomFactorL() >>"), RThread().Id().operator TUint()));

    User::Leave( KErrNotSupported );

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::SetDigitalZoomFactorL() <<"), RThread().Id().operator TUint()));

    }

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

// CVSStillImageDataProvider::StartViewFinderBitmapsL( TSize& aSize )

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

//

void CVSStillImageDataProvider::StartViewFinderBitmapsL( TSize& aSize )

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StartViewFinderBitmapsL() >>"), RThread().Id().operator TUint()));

    __ASSERT_DEBUG( iPSState > EPSUninitialized,

        Panic( EVSPanicProviderNotReady ) );

    iVFState = EVFPlaying;

    iViewer->ClearVFScalingTargetSize();

    iTargetSize = aSize;

    iViewer->SetVFScalingTargetSize( aSize );

    iViewer->ScaleCopy( aSize, ETrue );

    iViewer->IncreaseDataConsumer();

    iViewer->NextFrame();

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StartViewFinderBitmapsL() <<"), RThread().Id().operator TUint()));

    }

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

// CVSStillImageDataProvider::StartViewFinderBitmapsL(

//  TSize& /*aSize*/, TRect& /*aClipRect*/ )

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

//

void CVSStillImageDataProvider::StartViewFinderBitmapsL(

    TSize& /*aSize*/,

    TRect& /*aClipRect*/ )

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StartViewFinderBitmapsL() >>"), RThread().Id().operator TUint()));

    User::Leave( KErrNotSupported );

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StartViewFinderBitmapsL() <<"), RThread().Id().operator TUint()));

    }

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

// CVSStillImageDataProvider::StopViewFinder()

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

//

void CVSStillImageDataProvider::StopViewFinder()

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StopViewFinder() >>"), RThread().Id().operator TUint()));

    // Make sure scaler is cancelled (just in case!)

    iViewer->ClearVFScalingTargetSize();

    iViewer->DecreaseDataConsumer();

    iViewer->SetVFStop();

    // No double stopping..

    if( iVFState != EVFStopped )

        {

        iVFState = EVFStopped;

        iVFTimer->Cancel();

        }

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StopViewFinder() <<"), RThread().Id().operator TUint()));

    }

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

// CVSStillImageDataProvider::ViewFinderActive() const

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

//

TBool CVSStillImageDataProvider::ViewFinderActive() const

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::ViewFinderActive() >>"), RThread().Id().operator TUint()));

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::ViewFinderActive() <<"), RThread().Id().operator TUint()));

    return ( iVFState == EVFPlaying );

    }

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

// CVSStillImageDataProvider::StartViewFinderDirectL(

//  RWsSession& /*aWs*/, CWsScreenDevice& /*aScreenDevice*/,

//  RWindowBase& /*aWindow*/, TRect& /*aScreenRect*/ )

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

//

void CVSStillImageDataProvider::StartViewFinderDirectL(

    RWsSession& /*aWs*/,

    CWsScreenDevice& /*aScreenDevice*/,

    RWindowBase& /*aWindow*/,

    TRect& /*aScreenRect*/ )

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StartViewFinderDirectL() >>"), RThread().Id().operator TUint()));

    User::Leave(KErrNotSupported);

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StartViewFinderDirectL() <<"), RThread().Id().operator TUint()));

    }

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

// CVSStillImageDataProvider::StartViewFinderDirectL(

//  RWsSession& /*aWs*/, CWsScreenDevice& /*aScreenDevice*/,

//  RWindowBase& /*aWindow*/, TRect& /*aScreenRect*/, TRect& /*aClipRect*/ )

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

//

void CVSStillImageDataProvider::StartViewFinderDirectL(

    RWsSession& /*aWs*/,

    CWsScreenDevice& /*aScreenDevice*/,

    RWindowBase& /*aWindow*/,

    TRect& /*aScreenRect*/,

    TRect& /*aClipRect*/ )

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StartViewFinderDirectL() >>"), RThread().Id().operator TUint()));

    User::Leave(KErrNotSupported);

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::StartViewFinderDirectL() <<"), RThread().Id().operator TUint()));

    }

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

// CVSStillImageDataProvider::ProviderInfo( TVSDataProviderInfo& aInfo )

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

//

void CVSStillImageDataProvider::ProviderInfo( TVSDataProviderInfo& aInfo )

    {

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::ProviderInfo() >>"), RThread().Id().operator TUint()));

    Mem::FillZ( &aInfo, sizeof( aInfo ) );

    aInfo.iHardwareVersion = TVersion( 0, 0, 0 );

    aInfo.iSoftwareVersion = TVersion( 0, 0, 0 );

    aInfo.iOrientation = TCameraInfo::EOrientationUnknown;

    aInfo.iOptionsSupported = TCameraInfo::EViewFinderBitmapsSupported    |

                              TCameraInfo::EVideoCaptureSupported;

    aInfo.iFlashModesSupported = CCamera::EFlashNone;

    aInfo.iExposureModesSupported = CCamera::EExposureAuto;

    aInfo.iWhiteBalanceModesSupported = CCamera::EWBAuto;

    aInfo.iMinZoom = KMinZoom;

    aInfo.iMaxZoom = KMaxZoom;

    aInfo.iMaxDigitalZoom = KMaxDigitalZoom;

    aInfo.iMinZoomFactor = KMinZoomFactor;

    aInfo.iMaxZoomFactor = KMaxZoomFactor;

    aInfo.iMaxDigitalZoomFactor = KMaxDigitalZoomFactor;

    aInfo.iImageFormatsSupported = CCamera::EFormatFbsBitmapColor64K |

                                   CCamera::EFormatFbsBitmapColor16M;

    aInfo.iNumVideoFrameSizesSupported = KNumVideoSizesSupported;

    aInfo.iNumVideoFrameSizesSupported = KNumVideoFrameSizesSupported;

    aInfo.iNumVideoFrameRatesSupported = KNumVideoFrameRatesSupported;

    aInfo.iVideoFrameFormatsSupported = CCamera::EFormatYUV420Planar;

    aInfo.iMaxFramesPerBufferSupported = KMaxFramesPerBufferSupported;

    aInfo.iFreezeSupported = EFalse;

    aInfo.iSupportedColorTones =

        CCamera::CCameraImageProcessing::EEffectNone;

    __IF_DEBUG(Print(_L("VideoSource [%d]: CVSStillImageDataProvider::ProviderInfo() <<"), RThread().Id().operator TUint()));

    }