/*

* 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:  S60 DataBuffer Data Source Plugin implementation

*  Version     : %version: bh1mmcf#14.1.4 %

*

*/

#include "DataBufferDataSource.h"

#include <mmf/server/mmfdatabuffer.h>

#include "DataBufferSourceCustomCommands.h"

#include "SourceQueueItem.h"

#include "SinkQueueItem.h"

#include "DataCopyEngineAO.h"

#include "DataBufferSourceUid.h"

#include <MultimediaDataSourceEvents.h>

#include "DRMConfigIntfcImpl.h"

#include <mmfdatasink.h>

#include <mmfdatapath.h>

#include "tracemacros.h"

const TUint KMaxHeapForBuffering = 0x40000; // 256 KB (1 MB = default controller heap size).

CDataBufferSource* CDataBufferSource::NewL(TUid aType )

    {

    EMC_TRACE1(_L("CDataBufferSource::NewL"));

    CDataBufferSource* self = new (ELeave) CDataBufferSource(aType);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CDataBufferSource::CDataBufferSource(TUid aType)

: MDataSource(aType)

    {

    }

CDataBufferSource::~CDataBufferSource(void)

    {

    }

void CDataBufferSource::ConstructL (void)

    {

    }

// From MDataSource begins

TUid CDataBufferSource::DataSourceType() const

    {

    return KMmfDataBufferSource;

    }

TFourCC CDataBufferSource::SourceDataTypeCode(TMediaId /*aMediaId*/ )

    {

    TFourCC fourCC;        

    iMultiMediaSource->GetDataTypeCode(fourCC);

    return fourCC;

    }

TInt CDataBufferSource::SetSourceDataTypeCode(TFourCC aSourceFourCC,

                                                  TMediaId /*aMediaId*/ )

    {

    iMultiMediaSource->SetDataTypeCode(aSourceFourCC);

    return KErrNone;

    }

void CDataBufferSource::FillBufferL(CMMFBuffer* aBuffer,

                                        MDataSink* aConsumer,

                                        TMediaId /*aMediaId*/ )

    {

    User::LeaveIfError( iMultiMediaSource->ServiceFillBuffer( aBuffer, NULL, aConsumer ) );

    }

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

    {

    User::Leave(KErrUnknown);

    }

TBool CDataBufferSource::CanCreateSourceBuffer()

    {

    return EFalse;

    }

CMMFBuffer* CDataBufferSource::CreateSourceBufferL(TMediaId /*aMediaId*/,

                                                       TBool &/*aReference*/ )

    {

    /*    CMMFBuffer* newBuffer = 0; //dummy

    return newBuffer;

    */

    return NULL;

    }

TInt CDataBufferSource::SourceThreadLogon( MAsyncEventHandler& /*aEventHandler*/ )

    {

    return iMultiMediaSource->Open();

    }

void CDataBufferSource::SourceThreadLogoff()

    {

    iMultiMediaSource->Close();

    }

void CDataBufferSource::SourcePrimeL()

    {

    EMC_TRACE1(_L("CDataBufferSource::SourcePrimeL"));

    User::LeaveIfError(iMultiMediaSource->Prime());

    }

void CDataBufferSource::SourcePlayL()

    {

    EMC_TRACE1(_L("CDataBufferSource::SourcePlayL"));

    User::LeaveIfError(iMultiMediaSource->Play());

    }

void CDataBufferSource::SourceStopL()

    {

    EMC_TRACE1(_L("CDataBufferSource::SourceStopL"));

    User::LeaveIfError(iMultiMediaSource->Stop());

    }

void CDataBufferSource::ConstructSourceL(const TDesC8& /*aInitData*/ )

    {

    }

void CDataBufferSource::SourceCustomCommand(TMMFMessage& aMessage)

    {

    iMultiMediaSource->SourceCustomCommand(aMessage);        

    }

void CDataBufferSource::SetMultimediaSource(CDataBufferMultimediaSource& aMultimediaSource)

    {

    iMultiMediaSource = &aMultimediaSource;   

    }

// From MDataSource begins

// From CMultimediaDataSource begins

EXPORT_C CDataBufferMultimediaSource* CDataBufferMultimediaSource::NewL(MDataSource& aDataSource)

    {

    EMC_TRACE1(_L("CDataBufferMultimediaSource::NewL"));

    CDataBufferMultimediaSource* self = new (ELeave) CDataBufferMultimediaSource(aDataSource);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

CDataBufferMultimediaSource::CDataBufferMultimediaSource(MDataSource& aDataSource)

: iSrcItemsCount(0),

iSnkItemsCount(0),

iSrcBytes(0),

iSnkBytes(0),

iSizeBytes(0),

iTransferRate(0),

iBufferedDataSize(0),

iLastBufferReceived(EFalse),

iParentDataSource(&aDataSource)

    {

    // iState from Base

    iState = ECLOSED;

    iBufferingConfig.iType = TBufferingConfig::BUFFERINGNONE;

    iBufferingConfig.iAmount = 0;

    iMessage = NULL;

    }

CDataBufferMultimediaSource::~CDataBufferMultimediaSource(void)

    {

    EMC_TRACE1(_L("CDataBufferMultimediaSource::~CDataBufferMultimediaSource"));

    // Cancel data copying

    if(iDataCopyEngineAO)

    	{

    	iDataCopyEngineAO->Cancel();

    	delete iDataCopyEngineAO;

    	}

    iState = ECLOSED;

    // Empty source queue

    EmptySourceQueue();

    delete iSourceQueue;

    EmptySinkQueue();

    // Empty sink queue

    delete iSinkQueue;

    iAllowedOutputDeviceList.Close();

    }

void CDataBufferMultimediaSource::ConstructL (void)

    {

    static_cast<CDataBufferSource*>(iParentDataSource)->SetMultimediaSource(*this);

    iSourceQueue = new(ELeave) TSglQue<CSourceQueueItem>(_FOFF(CSourceQueueItem, iLink));

    iSinkQueue = new(ELeave) TSglQue<CSinkQueueItem>(_FOFF(CSinkQueueItem, iLink));

    iDataCopyEngineAO = CDataCopyEngineAO::NewL(iSourceQueue, iSinkQueue, *this);

    }

TInt CDataBufferMultimediaSource::SetObserver( MMultimediaDataSourceObserver& aObserver )

    {

    TInt status(KErrNotReady);

    switch ( iState )

        {

        case ECLOSED:

            iObserver = &aObserver;

            status = KErrNone;

            break;

        case ESTOPPED:

        case EPRIMED:

        case EEXECUTING:

        case EBUFFERING:

        default:

            EMC_TRACE2(_L("CDataBufferMultimediaSource::SetObserver[Illegal cmd on state[%d]]"), iState );

            break;

        };

    return status;

    }

TInt CDataBufferMultimediaSource::GetObserver( MMultimediaDataSourceObserver*& aObserver )

    {

    aObserver = iObserver;

    return KErrNone;

    }

void CDataBufferMultimediaSource::Event( TUid aEvent )

    {

    if ( aEvent == KMultimediaDataSourceEventBitRateChanged )

        {

        if(iMessage)

            {

            if(!iMessage->IsCompleted())

                {

                iMessage->Complete(KErrNone);

                delete iMessage;

                iMessage = NULL;

                }

            }

        }

    }

TInt CDataBufferMultimediaSource::SetDataTypeCode(TFourCC aSourceFourCC )

    {

    TInt status(KErrNone);

    iSourceFourCC = aSourceFourCC;

    return status;

    }

TInt CDataBufferMultimediaSource::GetDataTypeCode(TFourCC& aSourceFourCC )

    {

    TInt status(KErrNone);

    aSourceFourCC = iSourceFourCC;

    return status;

    }

TInt CDataBufferMultimediaSource::GetSize( TUint& aSize )

    {

    TInt status(KErrNone);

    aSize = iSizeBytes;

    return status;

    }

TInt CDataBufferMultimediaSource::Open()

    {

    TInt status(KErrNotReady);

    EMC_TRACE2(_L("CDataBufferSource::Open iState[%d]"),iState);

    switch ( iState )

        {

        case ECLOSED:

            iState = ESTOPPED;

            status = KErrNone;

            break;

        case ESTOPPED:

        case EPRIMED:

        case EEXECUTING:

        case EBUFFERING:

        default:

            status = KErrNone;

            EMC_TRACE2(_L("CDataBufferMultimediaSource::Open[Illegal cmd on state[%d]]"), iState );

            break;

        };

    return status;

    }

TInt CDataBufferMultimediaSource::Close()

    {

    TInt status(KErrNone);

    EMC_TRACE2(_L("CDataBufferSource::Close iState[%d]"),iState);

    iState = ECLOSED;

    // Clear app buffers

    EmptySinkQueue();

    iSnkBytes = 0;

    // Clear observer buffers

    EmptySourceQueue();

    iSrcBytes = 0;

    return status;

    }

TInt CDataBufferMultimediaSource::Prime()

    {

    TInt status(KErrNotReady);

    EMC_TRACE2(_L("CDataBufferSource::Prime iState[%d]"),iState);

    switch ( iState )

        {

        case ESTOPPED:

            iState = EPRIMED;

            status = KErrNone;

            break;

        case EPRIMED:

            // Clear observer buffers

            EmptySinkQueue();

            iSnkBytes = 0;

            status = KErrNone;

            break;

        case ECLOSED:

        case EEXECUTING:

        case EBUFFERING:

        default:

            EMC_TRACE2(_L("CDataBufferMultimediaSource::Prime[Illegal cmd on state[%d]]"), iState );

            break;

        };

    return status;

    }

TInt CDataBufferMultimediaSource::Play()

    {

    TInt status(KErrNotReady);

    EMC_TRACE2(_L("CDataBufferSource::Play iState[%d]"),iState); 

    switch ( iState )

        {

        case EPRIMED:

            iState = EEXECUTING;

            iDataCopyEngineAO->Start();

            status = KErrNone;

            break;

        case EEXECUTING:

        case EBUFFERING:

            // No op

            status = KErrNone;

            break;

        case ECLOSED:

        case ESTOPPED:

        default:

            EMC_TRACE2(_L("CDataBufferMultimediaSource::Play[Illegal cmd on state[%d]]"), iState );

            break;

        };

    return status;

    }

TInt CDataBufferMultimediaSource::Stop()

    {

    TInt status(KErrNotReady);

    EMC_TRACE2(_L("CDataBufferSource::Stop iState[%d]"),iState); 

    switch ( iState )

        {

        case EPRIMED:

        case EEXECUTING:

        case EBUFFERING:

            iState = ESTOPPED;

            // Stop data copy engine

            iDataCopyEngineAO->Stop();

            // Clear observer buffers

            status = EmptySourceQueue();

            iSrcBytes = 0;

            iLastBufferReceived = EFalse;

            // Clear app buffers

            status = EmptySinkQueue();

            iSnkBytes = 0;

            status = KErrNone;

            break;

        case ESTOPPED:

            // Stop data copy engine

            iDataCopyEngineAO->Stop();

            // Clear user buffers

            status = EmptySourceQueue();

            iSrcBytes = 0;

            iLastBufferReceived = EFalse;

            break;

        case ECLOSED:

        default:

            EMC_TRACE2(_L("CDataBufferMultimediaSource::Stop[Illegal cmd on state[%d]]"), iState );

            break;

        };

    return status;

    }

TInt CDataBufferMultimediaSource::FillBuffer( CMMFBuffer* aBuffer )

    {

    return ServiceFillBuffer( aBuffer, iObserver, NULL );

    }

TInt CDataBufferMultimediaSource::GetInterface(

        TUid aInterfaceId,

        TVersion& aVer,

        TAny*& aInterfaceImpl )

    {

    TInt status(KErrNotFound);

    aInterfaceImpl = NULL;

    if ( ( aInterfaceId == KDRMConfigIntfc ) &&

         ( ( aVer.iMajor == KDRMConfigIntfcMajorVer1 ) &&

           ( aVer.iMinor == KDRMConfigIntfcMinorVer1 ) &&

           ( aVer.iBuild == KDRMConfigIntfcBuildVer1 ) ) )

            {

            CDRMConfigIntcfImpl* temp(NULL);

            TRAP(status, temp = CDRMConfigIntcfImpl::NewL(*this));

            if ( status == KErrNone )

                {

                this->SetChild(*((CChildIntfc*)temp));

                temp->SetParent(*(CParentIntfc*)this);

                aInterfaceImpl = (CDRMConfigIntfc*)temp;

                }

            }

    return status;

    }

TAny* CDataBufferMultimediaSource::CustomInterface( TUid /*aInterfaceUid*/ )

    {

    return NULL;

    }

// From CMultimediaDataSource ends

// From MDataCopyEngineObserver begins

void CDataBufferMultimediaSource::SourceQueueItemProcessed()

    {

    iSrcItemsCount--;

    EMC_TRACE2(_L("CDataBufferMultimediaSource::SourceQueueItemProcessed[SrcItemsCount(%d)]"), iSrcItemsCount);

    CSourceQueueItem* srcItem = iSourceQueue->First();

    iSourceQueue->Remove(*srcItem);

    srcItem->CompleteMessage(KErrNone);

    delete srcItem;

    }

void CDataBufferMultimediaSource::SinkQueueItemProcessed()

    {

    iSnkItemsCount--;

    CSinkQueueItem* item = iSinkQueue->First();

    iSinkQueue->Remove(*item);

    iSnkBytes += item->Buffer()->Data().Length();

    EMC_TRACE3(_L("CDataBufferMultimediaSource::SinkQueueItemProcessed[Src[%d]B. Snk[%d]B]"), iSrcBytes, iSnkBytes);

    // If this is the last buffer being sent to the controller

    // empty the rest of the items in the sink queue

    if ( item->Buffer()->LastBuffer() )

        {

        EMC_TRACE1(_L("CDataBufferMultimediaSource::SinkQueueItemProcessed[LASTBUFFER]"));

        CSinkQueueItem* tempItem;

        while ( !iSinkQueue->IsEmpty() )

            {

            tempItem = iSinkQueue->First();

            iSinkQueue->Remove(*tempItem);

            delete tempItem;

            iSnkItemsCount--;

            }

        iSnkBytes = 0;

        iState = ESTOPPED;

        iSrcBytes = 0;

        }

    // Signal the controller, based on which FillBuffer API was called,

    // make the appriopriate callback.

    if ( item->Observer() )

        {

        item->Observer()->BufferFilled(item->Buffer());

        }

    else

        {

        TRAP_IGNORE(item->Consumer()->BufferFilledL(item->Buffer()));

        }

    delete item;

    }

// From MDataCopyEngineObserver ends

// To be called by DRMConfig Interface begins

TInt CDataBufferMultimediaSource::GetDRMType( TDRMType& aDRMType )

    {

    TInt status(KErrNotReady);

    switch ( iState )

        {

        case EPRIMED:

        case EEXECUTING:

        case EBUFFERING:

            aDRMType = iDRMType;

            status = KErrNone;

            break;

        case ECLOSED:

        case ESTOPPED:

        default:

            EMC_TRACE2(_L("CDataBufferMultimediaSource::GetDRMType[Illegal cmd on state[%d]]"), iState );

            break;

        };

    return status;

    }

TInt CDataBufferMultimediaSource::GetAllowedOutputDeviceCount( TInt& aCount )

    {

    TInt status(KErrNotReady);

    switch ( iState )

        {

        case EPRIMED:

        case EEXECUTING:

        case EBUFFERING:

            aCount = iAllowedOutputDeviceList.Count();

            status = KErrNone;

            break;

        case ECLOSED:

        case ESTOPPED:

        default:

            EMC_TRACE2(_L("CDataBufferMultimediaSource::GetDRMType[Illegal cmd on state[%d]]"), iState );

            break;