/*

* 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 <fbs.h>

#include "CVSCameraDataProvider.h"

#include "CVSOnboardCameraDataProvider.h"

#include "VSPanic.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 KQcifWidth = 176;

static const TInt KQcifHeight = 144;

static const TReal32 KFrameRate = 15.0;

static const TInt KFrozenFrameBufferSize = ( KQcifWidth * KQcifHeight ) + ( KQcifWidth * KQcifHeight ) / 2;

static const TInt KCCameraPriority = 80;

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

// ============================= CVsFrameBuffer ================================

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

// CVsFrameBuffer::NewL( TInt aSize )

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

//

EXPORT_C CVsFrameBuffer* CVsFrameBuffer::NewL( TInt aSize )

    {

    CVsFrameBuffer* self = new ( ELeave ) CVsFrameBuffer();

    CleanupStack::PushL( self );

    self->ConstructL( aSize );

    CleanupStack::Pop(); // self

    return self;

    }

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

// CVsFrameBuffer::~CVsFrameBuffer()

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

//

EXPORT_C CVsFrameBuffer::~CVsFrameBuffer()

    {

    delete iBuffer;

    }

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

// CVsFrameBuffer::CopyProperties( MFrameBuffer* aSource )

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

//

void CVsFrameBuffer::CopyProperties( MFrameBuffer* aSource )

    {

    MFrameBuffer::iIndexOfFirstFrameInBuffer = aSource->iIndexOfFirstFrameInBuffer;

    MFrameBuffer::iElapsedTime = aSource->iElapsedTime;

    }

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

// CVsFrameBuffer::CopyProperties( MCameraBuffer* aSource )

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

//

void CVsFrameBuffer::CopyProperties( MCameraBuffer* aSource )

    {

    MCameraBuffer::iIndexOfFirstFrameInBuffer = aSource->iIndexOfFirstFrameInBuffer;

    MCameraBuffer::iElapsedTime = aSource->iElapsedTime;

    }

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

// CVsFrameBuffer::CopyFrameL( MFrameBuffer* aSource )

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

//

void CVsFrameBuffer::CopyFrameL( MFrameBuffer* aSource )

    {

    iPtr = *( aSource->DataL( 0 ) );

    CopyProperties( aSource );

    }

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

// CVsFrameBuffer::CopyFrameL( MCameraBuffer* aSource )

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

//

void CVsFrameBuffer::CopyFrameL( MCameraBuffer* aSource )

	{

	iPtr = *( aSource->DataL( 0 ) );

    CopyProperties( aSource );

	}

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

// CVsFrameBuffer::DataL( TInt aIndex )

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

//

TDesC8* CVsFrameBuffer::DataL( TInt aIndex )

    {

    if( aIndex != 0 )

        {

        User::Leave( KErrNotSupported );

        }

    return &iPtr;

    }

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

// CVsFrameBuffer::FrameL( TInt aIndex )

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

//

CFbsBitmap* CVsFrameBuffer::FrameL( TInt aIndex )

    {

    ( void ) aIndex;

    User::Leave( KErrNotSupported );

    return 0;

    }

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

// CVsFrameBuffer::Release()

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

//

void CVsFrameBuffer::Release()

    {

    // Nothing to do

    }

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

// CVsFrameBuffer::FrameSize()

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

//

TInt CVsFrameBuffer::FrameSize( TInt /*aFrameIndex*/ )

    {

    return KErrNotSupported;

    }

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

// CVsFrameBuffer::ChunkOffsetL()

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

//

TInt CVsFrameBuffer::ChunkOffsetL( TInt /*aFrameIndex*/ )

    {

    User::Leave( KErrNotSupported );

    return KErrNotSupported;

    }

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

// CVsFrameBuffer::ChunkL()

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

//

RChunk& CVsFrameBuffer::ChunkL()

	{

	User::Leave( KErrNotSupported );

	RChunk* help = NULL;

	return *help;

	}

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

// CVsFrameBuffer::BitmapL()

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

//

CFbsBitmap& CVsFrameBuffer::BitmapL(TInt /*aFrameIndex*/ )

	{

	CFbsBitmap* helpbit = new (ELeave) CFbsBitmap;

	CleanupStack::PushL( helpbit );

	User::Leave( KErrNotSupported );

	CleanupStack::Pop( helpbit );

	delete helpbit;

	return *helpbit;

	}

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

// CVsFrameBuffer::NumFrames()

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

//

TInt CVsFrameBuffer::NumFrames()

	{

	return KErrNotSupported;

	}

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

// CVsFrameBuffer::CVsFrameBuffer()

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

//

CVsFrameBuffer::CVsFrameBuffer()

: iPtr( 0, 0 )

    {

    }

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

// CVsFrameBuffer::ConstructL( TInt aSize )

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

//

void CVsFrameBuffer::ConstructL( TInt aSize )

    {

    iBuffer = HBufC8::NewL( aSize );

    iPtr.Set( iBuffer->Des() );

    }

// ========================= CVSCameraDataProvider =============================

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

// CVSCameraDataProvider::NewL

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

//

CVSCameraDataProvider* CVSCameraDataProvider::NewL(

    MVSDataProviderObserver* aObserver,

    TInt aProviderIndex,

    MVSBufferPool* aPool )

    {

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

    CVSCameraDataProvider* self =

        new (ELeave) CVSOnboardCameraDataProvider( aObserver, aPool );

    CleanupStack::PushL( self );

    self->ConstructL( aProviderIndex );

    CleanupStack::Pop( self );

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

    return self;

    }

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

// CVSCameraDataProvider::~CVSCameraDataProvider

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

//

CVSCameraDataProvider::~CVSCameraDataProvider()

    {

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

    delete iFrozenFrame;

    delete iFrozenVFFrameCopy;

    delete iSource;

    delete iFrozenVFFrameToBeSent;

    delete iTarget;

    delete iScaler;

    delete iCamImgProc;

    if ( &Camera() != NULL )

        {

        Camera().Release();

        }

    delete iCamera;

    iFreezeCS.Close();

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

    }

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

// CVSCameraDataProvider::InitializeL

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

//

void CVSCameraDataProvider::InitializeL( const TDesC8& /*aInitParams*/ )

    {

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

    Camera().Reserve();

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

    }

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

// CVSCameraDataProvider::DigitalZoomFactor

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

//

TInt CVSCameraDataProvider::DigitalZoomFactor() const

    {

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

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

    return Camera().DigitalZoomFactor();

    }

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

// CVSCameraDataProvider::SetDigitalZoomFactorL

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

//

void CVSCameraDataProvider::SetDigitalZoomFactorL( TInt aDigitalZoomFactor)

    {

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

    Camera().SetDigitalZoomFactorL( aDigitalZoomFactor );

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

    }

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

// CVSCameraDataProvider::StartViewFinderBitmapsL

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

//

void CVSCameraDataProvider::StartViewFinderBitmapsL( TSize& aSize )

    {

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

    TCameraInfo info;

    Camera().CameraInfo( info );

    if ( !(info.iOptionsSupported & TCameraInfo::EViewFinderBitmapsSupported) )

        {

        User::Leave( KErrNotSupported );

        }

    if( IsFrozen()&& iHasFrozenVFFrameCopyCreated )

        {

        ScaleFrozenBitmapL( aSize );

        }

    Camera().StartViewFinderBitmapsL( aSize );

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

    }

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

// CVSCameraDataProvider::StartViewFinderBitmapsL

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

//

void CVSCameraDataProvider::StartViewFinderBitmapsL( TSize&, TRect& )

    {

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

    User::Leave( KErrNotSupported );

    }

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

// CVSCameraDataProvider::StopViewFinder

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

//

void CVSCameraDataProvider::StopViewFinder()

    {

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

    Camera().StopViewFinder();

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

    }

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

// CVSCameraDataProvider::ViewFinderActive

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

//

TBool CVSCameraDataProvider::ViewFinderActive() const

    {

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

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

    return Camera().ViewFinderActive();

    }

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

// CVSCameraDataProvider::StartViewFinderDirectL

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

//

void CVSCameraDataProvider::StartViewFinderDirectL( RWsSession&,

    CWsScreenDevice&, RWindowBase&, TRect& )

    {

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

    User::Leave( KErrNotSupported );

    }

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

// CVSCameraDataProvider::StartViewFinderDirectL

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

//

void CVSCameraDataProvider::StartViewFinderDirectL( RWsSession&,

    CWsScreenDevice&, RWindowBase&, TRect&, TRect& )

    {

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

    User::Leave( KErrNotSupported );

    }

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

// CVSCameraDataProvider::ProviderInfo

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

//

void CVSCameraDataProvider::ProviderInfo( TVSDataProviderInfo& aInfo )

    {

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

    Camera().CameraInfo( static_cast< TCameraInfo& >( aInfo ) );

    aInfo.iFreezeSupported = ETrue;

    TRAP_IGNORE( ProviderInfoExL( aInfo ) );

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

    }

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

// CVSCameraDataProvider::SetViewFinderMirrorL

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

//

void CVSCameraDataProvider::SetViewFinderMirrorL( TBool aMirror )

    {

    Camera().SetViewFinderMirrorL( aMirror );

    }

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

// CVSCameraDataProvider::ViewFinderMirror

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

//

TBool CVSCameraDataProvider::ViewFinderMirror() const

    {

    return Camera().ViewFinderMirror();

    }

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

// CVSCameraDataProvider::FreezeL

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

//

void CVSCameraDataProvider::FreezeL()

    {

    iFreezeCS.Wait();

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

    if( !IsFrozen() )

        {

        iFrozen = ETrue;

        iFrozenVfFrameReady = EFalse;

        iFreezePendingFlags = EViewFinderFreezePending | EVideoFrameFreezePending;

        }

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

    iFreezeCS.Signal();

    }

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

// CVSCameraDataProvider::UnfreezeL

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

//

void CVSCameraDataProvider::UnfreezeL()

    {

    iFreezeCS.Wait();

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

    if( IsFrozen() )

        {

        iFrozen = EFalse;

        iFreezePendingFlags = 0;

        iHasFrozenVFFrameCopyCreated = EFalse;

        }

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

    iFreezeCS.Signal();

    }

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

// CVSCameraDataProvider::IsFrozen

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

//

TBool CVSCameraDataProvider::IsFrozen() const

    {

    return iFrozen;

    }

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

// CVSCameraDataProvider::ImageReady

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

//

void CVSCameraDataProvider::ImageReady(

    CFbsBitmap* /*aBitmap*/, HBufC8* /*aData*/, TInt /*aError*/ )

    {

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

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

    }

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

// CVSCameraDataProvider::PowerOnComplete

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

//

void CVSCameraDataProvider::PowerOnComplete( TInt aError )

    {

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

    if ( !iPowerOnComplete )

        {

        if ( aError == KErrNone )

            {

            iPowerOnComplete = ETrue;

            iCameraHandle = Camera().Handle();

            // Setup ECAM so that the returned image is ok even if view finder

            // is asked before video

            TCameraInfo info;

            Camera().CameraInfo( info );

            if ( !(info.iOptionsSupported &

                TCameraInfo::EViewFinderBitmapsSupported) )

                {

                NotifyError( KErrNotSupported );

                return; // End debug print is missed

                }

            TInt sizeIndex, rateIndex;

            sizeIndex = rateIndex = 0;

            for (

                sizeIndex = 0;

                sizeIndex < info.iNumVideoFrameSizesSupported;

                sizeIndex++ )

                {

                TSize size;

                Camera().EnumerateVideoFrameSizes(

                    size,

                    sizeIndex,

                    CCamera::EFormatYUV420Planar );

                if ( size == TSize( KQcifWidth, KQcifHeight ) )

                    {

                    TReal32 rate;

                    for (

                        rateIndex = 0;

                        rateIndex < info.iNumVideoFrameRatesSupported;

                        rateIndex++ )

                        {

                        Camera().EnumerateVideoFrameRates(

                            rate,

                            rateIndex,

                            CCamera::EFormatYUV420Planar,

                            sizeIndex );

                        if ( KFrameRate == rate )

                            {

                            TRAPD(

                                err,

                                Camera().PrepareVideoCaptureL(

                                    CCamera::EFormatYUV420Planar,

                                    sizeIndex,

                                    rateIndex,

                                    2,

                                    1) );

                            if ( err != KErrNone )

                                {

                                NotifyError( err );

                                return; // End debug print is missed

                                }

                            break;

                            }

                        }

                    break;

                    }

                }

            Observer().vsProviderReady();

            }

        else

            {

            NotifyError( aError );

            }

        }