/*

* Copyright (c) 2009 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: 

*

*/

#include "baseprofilehandler.h"

_LIT(KErrDialogInvalidPortIndex, "Base Profile support command called on port not configured for base profile comms, component: %S, port: %d");

_LIT(KErrDialogBufferNumber, "Test script specified %d buffers, less than the port's minimum of %d, component: %S, port: %d");

_LIT(KErrDialogFillBufferInvalidBufIndex, "Test script specified invalid buffer index on a FillThisBuffer call, component: %S, port: %d, buffer index passed: %d");

_LIT(KErrDialogEmptyBufferInvalidBufIndex, "Test script specified invalid buffer index on a EmptyThisBuffer call, component: %S, port: %d, buffer index passed: %d");

CBaseProfileHandler::CBaseProfileHandler(ROmxScriptTest& aTestOwner, RASBreakEventHandler& aParentEventHandler)

: iErrorCallbacks(aTestOwner), iEventHandlerCallbacks(aParentEventHandler)

    {

    iOmxCallbacks.EmptyBufferDone = EmptyBufferDone;

    iOmxCallbacks.EventHandler = EventHandler;

    iOmxCallbacks.FillBufferDone = FillBufferDone;

    iMutex.CreateLocal();

    }

CBaseProfileHandler::~CBaseProfileHandler()

    {

    iMutex.Close();

    delete iXmlName;

    iBufferHeaders.ResetAndDestroy();

    iPortsUsingBaseProfile.Close();

    }

void CBaseProfileHandler::AddPortSupportL(TInt aPortIndex)

    {

    TPortInfo portInfo;

    portInfo.iPortIndex = aPortIndex;

    portInfo.iAutoMode = EFalse;

    portInfo.iWeAreBufferSupplier = ETrue;

    iPortsUsingBaseProfile.AppendL(portInfo);

    }

void CBaseProfileHandler::SetBufferSupplier(TInt aPortIndex, TBool aComponentBufferSupplier)

    {

    TInt portIndex = iPortsUsingBaseProfile.Find(aPortIndex, CBaseProfileHandler::PortIndexMatchComparison);

    if (portIndex == KErrNotFound)

        {

        TBuf<140> errorString;

        errorString.Format(KErrDialogInvalidPortIndex, iXmlName, aPortIndex);

        iErrorCallbacks.FailTest(errorString);

        return;

        }

    iPortsUsingBaseProfile[portIndex].iWeAreBufferSupplier = !aComponentBufferSupplier;

    }

void CBaseProfileHandler::SetAutoMode(TInt aPortIndex, TBool aAutoMode)

    {

    TInt portIndex = iPortsUsingBaseProfile.Find(aPortIndex, CBaseProfileHandler::PortIndexMatchComparison);

    if (portIndex == KErrNotFound)

        {

        TBuf<140> errorString;

        errorString.Format(KErrDialogInvalidPortIndex, iXmlName, aPortIndex);

        iErrorCallbacks.FailTest(errorString);

        return;

        }

    iPortsUsingBaseProfile[portIndex].iAutoMode = aAutoMode;

    }

TInt CBaseProfileHandler::LocateBufferForPort(TInt aPortIndex, TInt aBufferIndexInPort)

    {

    //Implementation based on the fact that:

    //-All the buffers for a port are allocated and appended to iBufferHeaders

    //in a single contiguous block.

    //-So once the first relevant buffer is found this index marks the zero index

    //for the set of indexed buffers relevant to that port.

    TInt result = -1;

    TInt bufferCount =  iBufferHeaders.Count();

    for (TInt bufferIndex = 0; bufferIndex < bufferCount; bufferIndex++)

        {

        if (iBufferHeaders[bufferIndex]->iPortIndex != aPortIndex)

            {

            continue;

            }

        //Safety check that the script hasn't made a manual Fill/Empty call on 

        //an invalid buffer index

        if (iBufferHeaders[bufferIndex]->iPortIndex == iBufferHeaders[(bufferIndex + aBufferIndexInPort)]->iPortIndex)

            {

            result = bufferIndex + aBufferIndexInPort;

            }

        break;

        }

    return result;

    }

void CBaseProfileHandler::FillThisBuffer(TInt aPortIndex, TInt aBufferIndexInPort)

    {

    TInt bufHeaderIndex = LocateBufferForPort(aPortIndex, aBufferIndexInPort);

    if (bufHeaderIndex >= 0)

        {

        iBufferHeaders[bufHeaderIndex]->iBufferAvailable = EFalse;

        iOmxComponent->FillThisBuffer(iOmxComponent, iBufferHeaders[bufHeaderIndex]->iBufferHeader);

        }

    else

        {

        TBuf<140> errorString;

        errorString.Format(KErrDialogFillBufferInvalidBufIndex, iXmlName, aPortIndex, aBufferIndexInPort);

        iErrorCallbacks.FailTest(errorString);

        }

    }

void CBaseProfileHandler::EmptyThisBuffer(TInt aPortIndex, TInt aBufferIndexInPort)

    {

    TInt bufHeaderIndex = LocateBufferForPort(aPortIndex, aBufferIndexInPort);

    if (bufHeaderIndex >= 0)

        {

        iBufferHeaders[bufHeaderIndex]->iBufferAvailable = EFalse;

        iOmxComponent->EmptyThisBuffer(iOmxComponent, iBufferHeaders[bufHeaderIndex]->iBufferHeader);

        }

    else

        {

        TBuf<140> errorString;

        errorString.Format(KErrDialogEmptyBufferInvalidBufIndex, iXmlName, aPortIndex, aBufferIndexInPort);

        iErrorCallbacks.FailTest(errorString);

        }    

    }

void CBaseProfileHandler::WaitForBufferCompletion(TInt aPortIndex, TInt aBufferIndexInPort)

    {

    TInt bufHeaderIndex = LocateBufferForPort(aPortIndex, aBufferIndexInPort);

    iMutex.Wait();

    if (iBufferHeaders[bufHeaderIndex]->iBufferAvailable)

        {

        //Buffer has already completed either while waiting on another buffer or as a result of test command processing delay, no need to wait

        iMutex.Signal();

        }

    else

        {

        iWaitingOnBuffer = iBufferHeaders[bufHeaderIndex]->iBufferHeader;

        iMutex.Signal();

        iErrorCallbacks.BeginWait();

        }

    }

OMX_ERRORTYPE CBaseProfileHandler::EventHandler(OMX_HANDLETYPE /*hComponent*/, OMX_PTR pAppData, OMX_EVENTTYPE eEvent, OMX_U32 nData1, OMX_U32 nData2, OMX_PTR pEventData)

    {

    reinterpret_cast<CBaseProfileHandler*>(pAppData)->HandleEventReceived(eEvent, nData1, nData2, pEventData);

    return OMX_ErrorNone;

    }

OMX_ERRORTYPE CBaseProfileHandler::FillBufferDone(OMX_IN OMX_HANDLETYPE /*hComponent*/, OMX_IN OMX_PTR pAppData, OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)

    {

    reinterpret_cast<CBaseProfileHandler*>(pAppData)->HandleFillBufferDone(pBuffer);

    return OMX_ErrorNone;

    }

OMX_ERRORTYPE CBaseProfileHandler::EmptyBufferDone(OMX_IN OMX_HANDLETYPE /*hComponent*/, OMX_IN OMX_PTR pAppData, OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)

    {

    reinterpret_cast<CBaseProfileHandler*>(pAppData)->HandleEmptyBufferDone(pBuffer);

    return OMX_ErrorNone;

    }

void CBaseProfileHandler::HandleEventReceived(OMX_EVENTTYPE aeEvent, OMX_U32 anData1, OMX_U32 anData2, OMX_PTR apEventData)

    {

    DoEventReceived(aeEvent, anData1, anData2, apEventData);

    iEventHandlerCallbacks.EventHandler(iOmxComponent, &iEventHandlerCallbacks, aeEvent, anData1, anData2, apEventData);

    }

void CBaseProfileHandler::HandleFillBufferDone(OMX_IN OMX_BUFFERHEADERTYPE* aFilledBuffer)

    {

    iMutex.Wait();

    DoFillBufferDone(aFilledBuffer);

    TInt bufferIndex = iBufferHeaders.Find(*aFilledBuffer, CBaseProfileHandler::BufferHeaderMatchComparison);

    iBufferHeaders[bufferIndex]->iBufferAvailable = ETrue;

    TInt portIndex = iPortsUsingBaseProfile.Find((*iBufferHeaders[bufferIndex]).iPortIndex, CBaseProfileHandler::PortIndexMatchComparison);

    if (iPortsUsingBaseProfile[portIndex].iAutoMode)

        {

        iBufferHeaders[bufferIndex]->iBufferAvailable = EFalse;

        iOmxComponent->FillThisBuffer(iOmxComponent, aFilledBuffer);

        }

    if (iWaitingOnBuffer == iBufferHeaders[bufferIndex]->iBufferHeader)

        {

        iWaitingOnBuffer = NULL;

        iErrorCallbacks.EndWait();

        }

    iMutex.Signal();

    }

void CBaseProfileHandler::HandleEmptyBufferDone(OMX_IN OMX_BUFFERHEADERTYPE* aEmptiedBuffer)

    {

    iMutex.Wait();

    DoEmptyBufferDone(aEmptiedBuffer);

    TInt bufferIndex = iBufferHeaders.Find(*aEmptiedBuffer, CBaseProfileHandler::BufferHeaderMatchComparison);

    iBufferHeaders[bufferIndex]->iBufferAvailable = ETrue;

    TInt portIndex = iPortsUsingBaseProfile.Find((*iBufferHeaders[bufferIndex]).iPortIndex, CBaseProfileHandler::PortIndexMatchComparison);

    if (iPortsUsingBaseProfile[portIndex].iAutoMode)

        {

        iBufferHeaders[bufferIndex]->iBufferAvailable = EFalse;

        iOmxComponent->EmptyThisBuffer(iOmxComponent, aEmptiedBuffer);

        }

    if (iWaitingOnBuffer == iBufferHeaders[bufferIndex]->iBufferHeader)

        {

        iWaitingOnBuffer = NULL;

        iErrorCallbacks.EndWait();

        }

    iMutex.Signal();

    }

OMX_COMPONENTTYPE* CBaseProfileHandler::LoadComponentL(const TDesC8& aTestSpecificName, const TDesC8& aOmxName)

    {

    iXmlName = HBufC::NewL(aTestSpecificName.Length());

	iXmlName->Des().Copy(aTestSpecificName);

    // allow room for the '\0' used in call to OMX_GetHandle

    HBufC8* omxNameToLoad = HBufC8::NewL(aOmxName.Length() + 1);

    *omxNameToLoad = aOmxName;

    OMX_ERRORTYPE error = OMX_GetHandle((TAny**) &iOmxComponent, (OMX_STRING) omxNameToLoad->Des().PtrZ(), this, &iOmxCallbacks);

    delete omxNameToLoad;

    if (error != OMX_ErrorNone)

        {

        iErrorCallbacks.FailWithOmxError(_L("OMX_GetHandle()"), error);

        }

    return iOmxComponent;

    }

void CBaseProfileHandler::FreeAllocatedBuffersL()	

	{

	for (TInt i = 0; i < iBufferHeaders.Count(); ++i)

		{

		delete iBufferHeaders[i];

		}

	iBufferHeaders.Reset();

	}

void CBaseProfileHandler::SetupBuffersL(TInt aPortIndex, TInt aNumberBuffers)

    {

    TInt portInfoIndex = iPortsUsingBaseProfile.Find(aPortIndex, CBaseProfileHandler::PortIndexMatchComparison);

    if (portInfoIndex == KErrNotFound)

        {

        TBuf<140> errorString;

        errorString.Format(KErrDialogInvalidPortIndex, iXmlName, aPortIndex);

        iErrorCallbacks.FailTest(errorString);

        return;   

        }

    OMX_PARAM_PORTDEFINITIONTYPE portDef;

    portDef.nSize = sizeof(portDef);

    portDef.nVersion = KOmxVersion;

    portDef.nPortIndex = aPortIndex;

    OMX_ERRORTYPE error = iOmxComponent->GetParameter(iOmxComponent, OMX_IndexParamPortDefinition, &portDef);

    if(error != OMX_ErrorNone)

        {

        iErrorCallbacks.FailWithOmxError(_L("GetParameter"), error);

        return;

        }

    if (aNumberBuffers < portDef.nBufferCountMin)

        {

        TBuf<140> errorString;

        errorString.Format(KErrDialogBufferNumber, aNumberBuffers, portDef.nBufferCountMin, iXmlName, aPortIndex);

        iErrorCallbacks.FailTest(errorString);

        return;

        }

    TInt bufSize = portDef.nBufferSize;    

    for (TInt bufIndex=0; bufIndex < aNumberBuffers; bufIndex++)

        {

        CBufferHeaderInfo* headerInfo = new (ELeave) CBufferHeaderInfo(*this);

        iBufferHeaders.AppendL(headerInfo);

        headerInfo->iPortIndex = aPortIndex;

        if (iPortsUsingBaseProfile[portInfoIndex].iWeAreBufferSupplier)

            {

            OMX_U8* buffer = new (ELeave) OMX_U8[bufSize];

            iOmxComponent->UseBuffer(iOmxComponent, &(headerInfo->iBufferHeader), aPortIndex, NULL, bufSize, buffer);

            }

        else

            {

            iOmxComponent->AllocateBuffer(iOmxComponent, &(headerInfo->iBufferHeader), aPortIndex, NULL, bufSize);

            }

        }

    }

void CBaseProfileHandler::DoEventReceived(OMX_EVENTTYPE /*aeEvent*/, OMX_U32 /*anData1*/, OMX_U32 /*anData2*/, OMX_PTR /*apEventData*/)

    {

    //Uninterested

    }

void CBaseProfileHandler::DoFillBufferDone(OMX_BUFFERHEADERTYPE* /*aFilledBuffer*/)

    {

    //Uninterested

    }

void CBaseProfileHandler::DoEmptyBufferDone(OMX_BUFFERHEADERTYPE* /*aEmptiedBuffer*/)

    {

    //Uninterested

    }

CBaseProfileHandler::CBufferHeaderInfo::CBufferHeaderInfo(CBaseProfileHandler& aParent)

: iBufferAvailable(ETrue), iParent(aParent)

    {

    }

CBaseProfileHandler::CBufferHeaderInfo::~CBufferHeaderInfo()

    {

    OMX_U8* buffer = iBufferHeader->pBuffer;

    OMX_ERRORTYPE error = iParent.iOmxComponent->FreeBuffer(iParent.iOmxComponent, iPortIndex, iBufferHeader);

    if (error != OMX_ErrorNone)

        {

        iParent.iErrorCallbacks.FailWithOmxError(_L("OMX_FreeBuffer()"), error);

        return;

        }

    TInt portInfoIndex = iParent.iPortsUsingBaseProfile.Find(iPortIndex, CBaseProfileHandler::PortIndexMatchComparison);

    if (iParent.iPortsUsingBaseProfile[portInfoIndex].iWeAreBufferSupplier)

        {

        delete[] buffer; 

        }

    }

TBool CBaseProfileHandler::PortIndexMatchComparison(const TInt* aPortIndex, const TPortInfo& aPortInfo)

    {

    if (*aPortIndex == aPortInfo.iPortIndex)

        {

        return ETrue;

        }

    return EFalse;

    }

TBool CBaseProfileHandler::BufferHeaderMatchComparison(const OMX_BUFFERHEADERTYPE* aBufferHeader, const CBufferHeaderInfo& aBufferHeaderInfo)

    {

    if (aBufferHeader == aBufferHeaderInfo.iBufferHeader)

        {

        return ETrue;

        }

    return EFalse;

    }