/*

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

#include <e32svr.h>

#include <badesca.h>

#include <mmfdatasourcesink.hrh>

#include "CVSMMFDataBuffer.h"

#include "CVSDataSourceImp.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;

 // 4:2:0 planar and 32 bytes extra

 static const TInt KSourceBufferSize =

    ( KQcifWidth * KQcifHeight ) + ( ( KQcifWidth * KQcifHeight ) / 2 ) + 12;

// Granularity for video frame format array

static const TInt KNoOfSupportedFormats = 4;

// How many sequential FillBufferL calls is supported

static const TInt KNoOfSupportedBuffers = 2;

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

// ============================ CVSProviderSwitchAO ============================

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

// CVSProviderSwitchAO::NewL

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

//

CVSProviderSwitchAO* CVSProviderSwitchAO::NewL(

    CVSDataSourceImp* aDataSourceImp )

    {

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

    CVSProviderSwitchAO* self =

        new ( ELeave ) CVSProviderSwitchAO( aDataSourceImp );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); // self

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

    return self;

    }

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

// CVSProviderSwitchAO::ConstructL

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

//

void CVSProviderSwitchAO::ConstructL()

    {

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

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

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

    }

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

// CVSProviderSwitchAO::CVSProviderSwitchAO

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

//

CVSProviderSwitchAO::CVSProviderSwitchAO( CVSDataSourceImp* aDataSourceImp )

: CActive( EPriorityStandard ), iDataSourceImp( aDataSourceImp )

    {

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

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

    }

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

// CVSProviderSwitchAO::~CVSProviderSwitchAO

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

//

CVSProviderSwitchAO::~CVSProviderSwitchAO()

    {

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

    iSwitchCs.Close();

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

    }

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

// CVSProviderSwitchAO::ThreadLogon

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

//

TInt CVSProviderSwitchAO::ThreadLogon( MAsyncEventHandler& aEventHandler )

    {

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

    iEventHandler = &aEventHandler;

    RThread me;

    iThreadId = me.Id();

    CActiveScheduler::Add( this );

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

    return KErrNone;

    }

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

// CVSProviderSwitchAO::ThreadLogoff

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

//

void CVSProviderSwitchAO::ThreadLogoff()

    {

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

    if( RThread().Id().operator TUint() == iThreadId )

        {

        Deque();

        iThreadId = 0;

        iNewProvider = NULL;

        }

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

    }

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

// CVSProviderSwitchAO::InitiateProviderSwitch

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

//

void CVSProviderSwitchAO::InitiateProviderSwitch(

    CVSDataProvider* aNewProvider )

    {

    iSwitchCs.Wait();

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

    iNewProvider = aNewProvider;

    iStatus = KRequestPending;

    SetActive();

    Signal( KErrNone );

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

    iSwitchCs.Signal();

    }

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

// CVSProviderSwitchAO::RunL

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

//

void CVSProviderSwitchAO::RunL()

    {

    iSwitchCs.Wait();

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

    if( iStatus.Int() == KErrNone )

        {

        if ( iDataSourceImp->SwitchPending() )

            {

            Panic( EVSPanicSwitchAlreadyPending );

            }

        TRAPD(

            leaveCode,

            iDataSourceImp->DoProviderSwitchL( iNewProvider, *iEventHandler ) );

        if ( leaveCode != KErrNone )

            {

            iDataSourceImp->ProviderSwitchError( leaveCode );

            }

        }

    else

        {

        iNewProvider = NULL;

        }

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

    iSwitchCs.Signal();

    }

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

// CVSProviderSwitchAO::DoCancel

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

//

void CVSProviderSwitchAO::DoCancel()

    {

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

    // Nothing to do here. This AO is always signalled when it's activated.

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

    }

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

// CVSProviderSwitchAO::Signal

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

//

void CVSProviderSwitchAO::Signal( TInt aError )

    {

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

    if( IsActive() )

        {

        TRequestStatus* pStatus = &iStatus;

        RThread me;

        if( me.Id() == iThreadId )

            {

            User::RequestComplete( pStatus, aError );

            }

        else

            {

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

                {

                *pStatus = KRequestPending;

                me.RequestComplete( pStatus, aError );

                me.Close();

                }

            else

                {

                Panic( EVSPanicThreadOpenFailure );

                }

            }

        }

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

    }

// ============================ CVSDataSourceObserverAO ========================

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

// CVSDataSourceObserverAO::CVSDataSourceObserverAO

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

//

CVSDataSourceObserverAO::CVSDataSourceObserverAO()

: CActive( EPriorityStandard )

    {

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

    RThread me;

    iThreadId = me.Id();

    CActiveScheduler::Add( this );

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

    }

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

// CVSDataSourceObserverAO::~CVSDataSourceObserverA

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

//

CVSDataSourceObserverAO::~CVSDataSourceObserverAO()

    {

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

    Cancel();

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

    }

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

// CVSDataSourceObserverAO::vsProviderSwitchDone

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

//

void CVSDataSourceObserverAO::vsProviderSwitchDone(

    MVSDataSourceObserver& aObserver,

    CVSDataProvider* aOldProvider )

    {

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

    iObserver = &aObserver;

    iOldProvider = aOldProvider;

    iStatus = KRequestPending;

    SetActive();

    Signal( KErrNone );

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

    }

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

// CVSDataSourceObserverAO::RunL

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

//

void CVSDataSourceObserverAO::RunL()

    {

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

    if( iStatus.Int() == KErrNone )

        {

        iObserver->vsProviderSwitchDone( iOldProvider );

        }

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

    }

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

// CVSDataSourceObserverAO::DoCancel

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

//

void CVSDataSourceObserverAO::DoCancel()

    {

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

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

    }

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

// CVSDataSourceObserverAO::Signal

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

//

void CVSDataSourceObserverAO::Signal( TInt aError )

    {

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

    TRequestStatus* pStatus = &iStatus;

    RThread me;

    if( me.Id() == iThreadId )

        {

        User::RequestComplete( pStatus, aError );

        }

    else

        {

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

            {

            *pStatus = KRequestPending;

            me.RequestComplete( pStatus, aError );

            me.Close();

            }

        else

            {

            Panic( EVSPanicThreadOpenFailure );

            }

        }

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

    }

// =============================== CVSDataSource ===============================

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

// CVSDataSource::NewSourceL

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

//

CVSDataSource* CVSDataSource::NewSourceL( MVSDataSourceObserver* aObserver )

    {

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

    if ( aObserver == NULL )

        {

        User::Leave( KErrArgument );

        }

    CVSDataSource* self = CVSDataSourceImp::NewSourceL();

    CleanupStack::PushL( self );

    self->ConstructL( aObserver );

    CleanupStack::Pop( self );

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

    return self;

    }

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

// CVSDataSource::CVSDataSource

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

//

CVSDataSource::CVSDataSource() : MVTVideoSource( KNullUid )

    {

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

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

    }

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

// CVSDataSource::ConstructL

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

//

void CVSDataSource::ConstructL( MVSDataSourceObserver* aObserver )

    {

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

    iObserver = aObserver;

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

    }

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

// CVSDataSourceImp::NewSourceL

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

//

CVSDataSourceImp* CVSDataSourceImp::NewSourceL()

    {

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

    CVSDataSourceImp* self = new (ELeave) CVSDataSourceImp;

    CleanupStack::PushL( self );

    self->ConstructSourceL( KNullDesC8 );

    CleanupStack::Pop( self );

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

    return self;

    }

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

// CVSDataSourceImp::SwitchDataProviderL

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

//

void CVSDataSourceImp::SwitchDataProviderL(

    CVSDataProvider* aNewProvider )

    {

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

    if ( aNewProvider == NULL )

        {

        __IF_DEBUG(Print(_L("SwitchDataProviderL(): NULL argument, leaving.")));

        User::Leave( KErrArgument );

        }

    // Is new provider same as old, then no need to change provider

    if ( aNewProvider == &DataProvider() )

        {

        __IF_DEBUG(Print(_L("SwitchDataProviderL(): New provider same as old: 0x%x"), aNewProvider));

        Observer().vsProviderSwitchDone( aNewProvider );

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

        return;

        }

    // If Protocol is in the currently initializing itself then complete this switch

    // request when Protocol ready (from SourcePlayL). No need to protect

    // iProtoInitOngoing test with CS.

    if ( iProtoInitOngoing )

        {

        __IF_DEBUG(Print(_L("PROTOCOL INIT ONGOING, PENDING SWITCH FOR A WHILE")));

        iProtoInitCS.Wait();

        iProviderSwitchRequestDuringProtoInit = ETrue;

        iNewProvider = aNewProvider;

        iProtoInitCS.Signal();

        return;

        }

    // Switch provider

    if ( iThreadLogonCalled )

        {

        iProviderSwitchAO->InitiateProviderSwitch( aNewProvider );

        }

    else

        {

        CVSDataProvider* oldProvider = SwitchProvider( aNewProvider );

        Observer().vsProviderSwitchDone( oldProvider );

        }

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

    }

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

// CVSDataSourceImp::PauseSending

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

//

void CVSDataSourceImp::PauseSending()

    {

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

    iPauseCs.Wait();

    iSendingPaused = ETrue;

    iPauseCs.Signal();

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

    }

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

// CVSDataSourceImp::ResumeSending

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

//

void CVSDataSourceImp::ResumeSending()

    {

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

    iPauseCs.Wait();

    iSendingPaused = EFalse;

    iPauseCs.Signal();

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

    }

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

// CVSDataSourceImp::~CVSDataSourceImp

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

//

CVSDataSourceImp::~CVSDataSourceImp()

    {

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

    delete iDataSourceObserverAO;

    delete iProviderSwitchAO;

    iProtoMimeTypes.Close();

    delete iSupportedVideoFormats;

    iSupportedVideoSizes.Close();

    iSupportedFrameRates.Close();

    // Assuming no need to use critical section here

    iFreeQueue.Close();

    iActiveQueue.Close();

    iAllocatedBuffers.ResetAndDestroy();

    iQueueCs.Close();

    iPauseCs.Close();

    iProtoInitCS.Close();

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

    }

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

// CVSDataSourceImp::FillBufferL

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

//

void CVSDataSourceImp::FillBufferL(

    CMMFBuffer* aBuffer,

    MVTVideoSink* aConsumer,

    TMediaId aMediaId )

    {

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

    if ( aBuffer == NULL || aConsumer == NULL )

        {

        User::Leave( KErrArgument );

        }

    if ( aBuffer->Type() != KUidMmfDataBuffer )

        {

        User::Leave( KErrArgument );

        }

    DataProvider().SetFillBufferParams( aConsumer, aMediaId );

    iPauseCs.Wait();

    const TBool sendingPaused( iSendingPaused );

    iPauseCs.Signal();

    if( iSwitchOngoing )

        {

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

        // queues are locked by us -> it's safe to modify queues without

        // locking

        User::LeaveIfError(

            FreeBufferNoWait( static_cast<CVSMMFDataBuffer*>( aBuffer ) ) );

        }

    else if( iSwitchPending )

        {

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

        FreeBufferL( static_cast<CVSMMFDataBuffer*>( aBuffer ) );

        TRAPD(

            err,

            DoProviderSwitchL(

                iProviderSwitchAO->NewDataProvider(),

                iProviderSwitchAO->EventHandler() ) );

        if( err != KErrNone )

            {

            __IF_DEBUG(Print(_L("VideoSource[%d]: CVSDataSourceImp::FillBufferL(): Error in switch = %d"), RThread().Id().operator TUint(), err));

            // Not leaving from here (it was provider switch related error),