/*

* 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 "CVSOnboardCameraDataProvider.h"

#include "CVSDataSourceImp.h"

#include "VSPanic.h"

#include "CVSMMFDataBuffer.h"

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KQCIFWidth = 176;

const TInt KQCIFHeight = 144;

// MACROS

#ifdef _DEBUG

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

#else

#    define __IF_DEBUG(t)

#endif

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

// ============================ CProviderErrorNotifierAO =======================

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

// CProviderErrorNotifierAO::NewL

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

//

CProviderErrorNotifierAO* CProviderErrorNotifierAO::NewL()

    {

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

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); // self

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

    return self;

    }

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

// CProviderErrorNotifierAO::~CProviderErrorNotifierAO

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

//

CProviderErrorNotifierAO::~CProviderErrorNotifierAO()

    {

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

    Cancel();

    iCS.Close();

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

    }

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

// CProviderErrorNotifierAO::NotifyError

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

//

void CProviderErrorNotifierAO::NotifyError(

    MVSDataProviderObserver* aObserver,

    TInt aError )

    {

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

    iCS.Wait();

    iObserver = aObserver;

    iError = aError;

    TRequestStatus* statusP = &iStatus;

    RThread thread;

    if( thread.Open( iThreadId ) == KErrNone )

        {

        *statusP = KRequestPending;

        thread.RequestComplete( statusP, KErrNone );

        thread.Close();

        }

    else

        {

        Panic( EVSPanicThreadOpenFailure );

        }

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

    }

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

// CProviderErrorNotifierAO::CProviderErrorNotifierAO

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

//

CProviderErrorNotifierAO::CProviderErrorNotifierAO() :

    CActive( EPriorityNormal )

    {

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

    CActiveScheduler::Add( this );

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

    }

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

// CProviderErrorNotifierAO::ConstructL

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

//

void CProviderErrorNotifierAO::ConstructL()

    {

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

    iCS.CreateLocal();

    iThreadId = RThread().Id();

    iStatus = KRequestPending;

    SetActive();

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

    }

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

// CProviderErrorNotifierAO::DoCancel

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

//

void CProviderErrorNotifierAO::DoCancel()

    {

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

    if( iStatus == KRequestPending )

        {

        TRequestStatus* status = &iStatus;

        User::RequestComplete( status, KErrCancel );

        }

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

    }

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

// CProviderErrorNotifierAO::RunL

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

//

void CProviderErrorNotifierAO::RunL()

    {

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

    TInt err = iStatus.Int();

    if ( err == KErrCancel )

        {

        return;

        }

    if ( iObserver != NULL )

        {

        iObserver->vsProviderError( iError );

        }

    iStatus = KRequestPending;

    SetActive();

    iCS.Signal();

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

    }

// ============================ CSyncCameraReserve =============================

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

// CSyncCameraReserve::CSyncCameraReserve

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

//

CSyncCameraReserve::CSyncCameraReserve() : CActive( EPriorityNormal )

    {

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

    CActiveScheduler::Add( this );

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

    }

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

// CSyncCameraReserve::StartL

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

//

void CSyncCameraReserve::StartL()

    {

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

    SetActive();

    iStatus = KRequestPending;

    iWait.Start();

    User::LeaveIfError( iStatus.Int() );

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

    }

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

// CSyncCameraReserve::NewL

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

//

CSyncCameraReserve* CSyncCameraReserve::NewL()

    {

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

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

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

    return self;

    }

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

// CSyncCameraReserve::DoCancel

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

//

void CSyncCameraReserve::DoCancel()

    {

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

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

    }

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

// CSyncCameraReserve::RunL

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

//

void CSyncCameraReserve::RunL()

    {

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

    iWait.AsyncStop();

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

    }

// ============================ CVSOnboardCameraDataProvider ===================

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

// CVSOnboardCameraDataProvider::CVSOnboardCameraDataProvider

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

//

CVSOnboardCameraDataProvider::CVSOnboardCameraDataProvider(

    MVSDataProviderObserver* aObserver, MVSBufferPool* aPool ) :

        CVSCameraDataProvider( aObserver, aPool ),iCameraLost( EFalse )

    {

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

    iState = EStopped;

    iFormat = CCamera::EFormatYUV420Planar;

    iDublicatedBitmap = new CFbsBitmap();

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

    }

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

// CVSOnboardCameraDataProvider::~CVSOnboardCameraDataProvider

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

//

CVSOnboardCameraDataProvider::~CVSOnboardCameraDataProvider()

    {

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

    delete iDublicatedBitmap;

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

    }

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

// CVSOnboardCameraDataProvider::PrimeL

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

//

void CVSOnboardCameraDataProvider::PrimeL()

    {

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

    const TBool primeable( iCameraDuplicate && ( iState == EStopped ) );

    if ( !primeable )

        {

        User::Leave( KErrNotReady );

        }

    iAsynchronousReserveIssued = EFalse;

    iCameraDuplicate->Reserve();

    iSyncReserve->StartL(); // Returns when from ReserveComplete() has been

                            // signalled iSyncReserve

    // Reserve ok, prepare capture next

    iCameraDuplicate->PrepareVideoCaptureL(

        iFormat,

        iFrameSizeIndex,

        iFrameRateIndex,

        2,

        1 );

    SetVideoFrameSizeL( TSize( KQCIFWidth, KQCIFHeight ) );

    iState = EPrimed;

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

    }

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

// CVSOnboardCameraDataProvider::FillBufferL

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

//

void CVSOnboardCameraDataProvider::FillBufferL(

    CMMFBuffer* /*aBuffer*/,

    MVTVideoSink* /*aConsumer*/,

    TMediaId /*aMediaId*/ )

    {

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

    if ( iState != EPlaying )

        {

        User::Leave( KErrNotReady );

        }

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

    }

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

// CVSOnboardCameraDataProvider::BufferEmptiedL

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

//

void CVSOnboardCameraDataProvider::BufferEmptiedL( CMMFBuffer* /*aBuffer*/ )

    {

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

    User::Leave( KErrNotSupported );

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

    }

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

// CVSOnboardCameraDataProvider::SourceThreadLogon

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

//

TInt CVSOnboardCameraDataProvider::SourceThreadLogon(

    MAsyncEventHandler& aEventHandler )

    {

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

    TInt err = KErrNone;

    iEventHandler = &aEventHandler;

    if ( iCameraDuplicate )

        {

        Panic( EVSPanicProviderAlreadyInitialized );

        }

    TRAP( err, iCameraDuplicate =

        CCamera::NewDuplicate2L( (MCameraObserver2&)*this, iCameraHandle) );

    if ( err != KErrNone )

        {

        TRAP( err, iCameraDuplicate =

        CCamera::NewDuplicateL( (MCameraObserver&)*this, iCameraHandle) );

        if (err != KErrNone)

        	{

        	return err;

        	}

        }

    iCameraLost = EFalse;

    TCameraInfo info;

    iCameraDuplicate->CameraInfo( info );

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

        {

        delete iCameraDuplicate;

        iCameraDuplicate = NULL;

        return KErrNotSupported;

        }

    if ( iSyncReserve == NULL )

        {

        TRAP( err, iSyncReserve = CSyncCameraReserve::NewL() );

        if ( err != KErrNone )

            {

            delete iCameraDuplicate;

            iCameraDuplicate = NULL;

            }

        }

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

    return err;

    }

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

// CVSOnboardCameraDataProvider::SourceThreadLogoff

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

//

void CVSOnboardCameraDataProvider::SourceThreadLogoff()

    {

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

    delete iCameraDuplicate;

    iCameraDuplicate = NULL;

    iState = EStopped;

    delete iSyncReserve;

    iSyncReserve = NULL;

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

    }

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

// CVSOnboardCameraDataProvider::SourcePrimeL

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

//

void CVSOnboardCameraDataProvider::SourcePrimeL()

    {

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

    const TBool primeable( iCameraDuplicate && ( iState == EStopped ) );

    if ( !primeable )

        {

        User::Leave( KErrNotReady );

        }

    iAsynchronousReserveIssued = ETrue;

    iCameraDuplicate->Reserve();

    User::Leave( KRequestPending );

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

    }

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

// CVSOnboardCameraDataProvider::SourcePlayL

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

//

void CVSOnboardCameraDataProvider::SourcePlayL()

    {

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

    if ( iState != EPrimed )

        {

        User::Leave( KErrNotReady );

        }

    ResetStartTime();

    iCameraDuplicate->StartVideoCapture();

    iState = EPlaying;

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

    }

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

// CVSOnboardCameraDataProvider::SourcePauseL

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

//

void CVSOnboardCameraDataProvider::SourcePauseL()

    {

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

    if ( iState != EPlaying )

        {

        return;

        }

    iCameraDuplicate->StopVideoCapture();

    iState = EPrimed;

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

    }

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

// CVSOnboardCameraDataProvider::SourceStopL

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

//

void CVSOnboardCameraDataProvider::SourceStopL()

    {

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

    if ( iState == EStopped )

        {

        return;

        }

    SourcePauseL();

    iCameraDuplicate->Release();

    iState = EStopped;

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

    }

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

// CVSOnboardCameraDataProvider::SetFormatL

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

//

void CVSOnboardCameraDataProvider::SetFormatL( const TDesC8& aFormat )

    {

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

    if ( !iCameraDuplicate )

        {

        User::Leave( KErrBadHandle );

        }

    TCameraInfo info;

    iCameraDuplicate->CameraInfo( info );

    if ( aFormat == KVtVideoMIMETypeYUV420 )

        {

        if ( info.iVideoFrameFormatsSupported & CCamera::EFormatYUV420Planar )

            {

            iFormat = CCamera::EFormatYUV420Planar;

            }

        else

            {

            User::Leave( KErrNotSupported );

            }

        }

    else

        {

        User::Leave( KErrNotSupported );

        }

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

    }

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

// CVSOnboardCameraDataProvider::SetFrameRateL

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

//

void CVSOnboardCameraDataProvider::SetFrameRateL( TReal32 aFrameRate )

    {

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

    if ( !iCameraDuplicate )

        {

        User::Leave( KErrBadHandle );

        }

    TCameraInfo info;

    iCameraDuplicate->CameraInfo( info );

    TBool found = EFalse;

    for ( TInt i = 0; i < info.iNumVideoFrameRatesSupported; i++ )

        {

        TReal32 rate = 0;

        iCameraDuplicate->EnumerateVideoFrameRates(

            rate,

            i,

            iFormat,

            iFrameSizeIndex );

        if ( rate == aFrameRate )

            {

            iFrameRateIndex = i;

            found = ETrue;

            break;

            }

        }

    if ( !found )

        {

        User::Leave( KErrNotSupported );

        }

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

    }

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

// CVSOnboardCameraDataProvider::SetVideoFrameSizeL

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

//

void CVSOnboardCameraDataProvider::SetVideoFrameSizeL( const TSize& aSize )

    {

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

    if ( !iCameraDuplicate )

        {

        User::Leave( KErrBadHandle );

        }

    TCameraInfo info;

    iCameraDuplicate->CameraInfo( info );

    TBool found = EFalse;

    for ( TInt i = 0; i < info.iNumVideoFrameSizesSupported; i++ )

        {