/*

* Copyright (c) 2008 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 "nontunneledhandler.h"

CNonTunneledHandler::CNonTunneledHandler()

	{

	}

CNonTunneledHandler::~CNonTunneledHandler()

	{

	}

void CNonTunneledHandler::AddLinkL(OMX_COMPONENTTYPE* aSourceComp,

                                   TInt aSourcePort,

                                   OMX_COMPONENTTYPE* aSinkComp,

                                   TInt aSinkPort,

                                   OMX_BUFFERSUPPLIERTYPE aSupplier,

                                   TInt aNumBufs, TInt aBufSize)

	{

	CComponentInfo* compInfo = NULL;

	TInt pos = iComponents.Find(*aSourceComp, CComponentInfo::CompareComp);

	if (pos >= 0)

		{

		compInfo = iComponents[pos];

		}

	else

		{

		compInfo = new (ELeave) CComponentInfo(aSourceComp);

		CleanupStack::PushL(compInfo);

		iComponents.AppendL(compInfo);

		CleanupStack::Pop(compInfo);

		}

	CPortInfo* sourcePortInfo = compInfo->AddPortL(aSourcePort, ETrue, aNumBufs, aBufSize, aSupplier);

	pos = iComponents.Find(*aSinkComp, CComponentInfo::CompareComp);

	if (pos >= 0)

		{

		compInfo = iComponents[pos];

		}

	else

		{

		compInfo = new (ELeave) CComponentInfo(aSinkComp);

		CleanupStack::PushL(compInfo);

		iComponents.AppendL(compInfo);

		CleanupStack::Pop(compInfo);

		}

	CPortInfo* sinkPortInfo = compInfo->AddPortL(aSinkPort, EFalse, aNumBufs, aBufSize, aSupplier);

	sourcePortInfo->SetPeer(sinkPortInfo);

	sinkPortInfo->SetPeer(sourcePortInfo);

	}

void CNonTunneledHandler::AllocateBuffersL(OMX_COMPONENTTYPE* aComp)

	{

	TInt pos = iComponents.Find(*aComp, CComponentInfo::CompareComp);

	if (pos >= 0)

		{

		iComponents[pos]->AllocateBuffersL();

		}

	}

void CNonTunneledHandler::FillBuffers(OMX_COMPONENTTYPE* aComp)

	{

	TInt pos = iComponents.Find(*aComp, CComponentInfo::CompareComp);

	if (pos >= 0)

		{

		iComponents[pos]->FillBuffers();

		}	

	}

void CNonTunneledHandler::BufferDone(OMX_COMPONENTTYPE* aComp, OMX_BUFFERHEADERTYPE* aBufHdr, TBool aSource)

	{

	TInt pos = iComponents.Find(*aComp, CComponentInfo::CompareComp);

	if (pos >= 0)

		{

		iComponents[pos]->BufferDone(aBufHdr, aSource);

		}

	}

void CNonTunneledHandler::HoldBuffers(OMX_COMPONENTTYPE* aComp)

	{

	TInt pos = iComponents.Find(*aComp, CComponentInfo::CompareComp);

	if (pos >= 0)

		{

		iComponents[pos]->HoldBuffers();

		}	

	}

void CNonTunneledHandler::FreeBuffers(OMX_COMPONENTTYPE* aComp)

	{

	TInt pos = iComponents.Find(*aComp, CComponentInfo::CompareComp);

	if (pos >= 0)

		{

		iComponents[pos]->FreeBuffers();

		}	

	}

CNonTunneledHandler::CComponentInfo::CComponentInfo(OMX_COMPONENTTYPE* aComp) :

 iComp(aComp)

	{

	}

CNonTunneledHandler::CComponentInfo::~CComponentInfo()

	{

	iPorts.ResetAndDestroy();

	}

CNonTunneledHandler::CPortInfo* CNonTunneledHandler::CComponentInfo::AddPortL(TInt aPortNum, TBool aSource, TInt aNumBufs, TInt aBufSize, OMX_BUFFERSUPPLIERTYPE aSupplier)

	{

	__ASSERT_ALWAYS(iPorts.Find(aPortNum, CPortInfo::ComparePortNum) == KErrNotFound, User::Invariant());

	CPortInfo* portInfo = new (ELeave) CPortInfo(iComp, aPortNum, aSource, aNumBufs, aBufSize, aSupplier);

	CleanupStack::PushL(portInfo);

	iPorts.AppendL(portInfo);

	CleanupStack::Pop(portInfo);

	return portInfo;

	}

void CNonTunneledHandler::CComponentInfo::AllocateBuffersL()

	{

	TInt numPorts = iPorts.Count();

	for (TInt port = 0; port < numPorts; ++port)

		{

		iPorts[port]->AllocateBuffersL();

		}

	}

void CNonTunneledHandler::CComponentInfo::FillBuffers()

	{

	TInt numPorts = iPorts.Count();

	for (TInt port = 0; port < numPorts; ++port)

		{

		iPorts[port]->FillBuffers();

		}

	}

void CNonTunneledHandler::CComponentInfo::BufferDone(OMX_BUFFERHEADERTYPE* aBufHdr, TBool aSource)

	{

	TInt pos = KErrNotFound;

	if (aSource)

		{

		pos = iPorts.Find(static_cast<TInt>(aBufHdr->nOutputPortIndex), CPortInfo::ComparePortNum);

		}

	else

		{

		pos = iPorts.Find(static_cast<TInt>(aBufHdr->nInputPortIndex), CPortInfo::ComparePortNum);

		}

	__ASSERT_ALWAYS(pos != KErrNotFound, User::Invariant());

	iPorts[pos]->BufferDone(aBufHdr);

	}

void CNonTunneledHandler::CComponentInfo::HoldBuffers()

	{

	for (TInt port = 0; port < iPorts.Count(); ++port)

		{

		iPorts[port]->HoldBuffers();

		}

	}

void CNonTunneledHandler::CComponentInfo::FreeBuffers()

	{

	for (TInt port = 0; port < iPorts.Count(); ++port)

		{

		iPorts[port]->FreeBuffers();

		}

	}

TBool CNonTunneledHandler::CComponentInfo::CompareComp(const OMX_COMPONENTTYPE* aComp, const CComponentInfo& aComponentInfo)

	{

	return (aComp == aComponentInfo.iComp);

	}

CNonTunneledHandler::CPortInfo::CPortInfo(OMX_COMPONENTTYPE* aComp, TInt aPortNum, TBool aSource, TInt aNumBufs, TInt aBufSize, OMX_BUFFERSUPPLIERTYPE aSupplier) :

 iComp(aComp),

 iPortNum(aPortNum),

 iSource(aSource),

 iNumBufs(aNumBufs),

 iBufSize(aBufSize),

 iSupplier(aSupplier),

 iEosSignalledtoInput(FALSE)

	{

	}

CNonTunneledHandler::CPortInfo::~CPortInfo()

	{

	DeleteAllBuffers();

	}

void CNonTunneledHandler::CPortInfo::SetPeer(CPortInfo* aPeer)

	{

	iPeer = aPeer;

	}

void CNonTunneledHandler::CPortInfo::AllocateBuffersL()

	{

	OMX_BUFFERHEADERTYPE* bufHdr = NULL;

	if (iSource)

		{

		if (iSupplier == OMX_BufferSupplyUnspecified)

			{

			OMX_U8* newBuffer = NULL;

			for (TInt buf = 0; buf < iNumBufs; ++buf)

				{

				newBuffer = new (ELeave) OMX_U8[iBufSize];

				CleanupStack::PushL(newBuffer);

				iBuffers.AppendL(newBuffer);

				CleanupStack::Pop(newBuffer);

				iComp->UseBuffer(iComp, &bufHdr, iPortNum, NULL, iBufSize, newBuffer);

				iBufferHeaders.AppendL(bufHdr);

				SendAllocatedBufferToPeerL(newBuffer);

				}

			}

		else if (iSupplier == OMX_BufferSupplyOutput)

			{

			for (TInt buf = 0; buf < iNumBufs; ++buf)

				{			

				iComp->AllocateBuffer(iComp, &bufHdr, iPortNum, NULL, iBufSize);

				iBufferHeaders.AppendL(bufHdr);

				SendAllocatedBufferToPeerL(bufHdr->pBuffer);

				}

			}

		else

			{

			TInt bufCount = iBuffers.Count();

			for (TInt buf = 0; buf < bufCount; ++buf)

				{

				iComp->UseBuffer(iComp, &bufHdr, iPortNum, NULL, iBufSize, iBuffers[buf]);

				iBufferHeaders.AppendL(bufHdr);

				}

			if (bufCount < iNumBufs)

				{

				iWaitingForBuffers = ETrue;

				}

			}

		}

	else

		{

		if (iSupplier == OMX_BufferSupplyInput)

			{

			for (TInt buf = 0; buf < iNumBufs; ++buf)

				{

				iComp->AllocateBuffer(iComp, &bufHdr, iPortNum, NULL, iBufSize);

				iBufferHeaders.AppendL(bufHdr);

				SendAllocatedBufferToPeerL(bufHdr->pBuffer);

				}

			}

		else

			{

			TInt bufCount = iBuffers.Count();

			for (TInt buf = 0; buf < bufCount; ++buf)

				{

				iComp->UseBuffer(iComp, &bufHdr, iPortNum, NULL, iBufSize, iBuffers[buf]);

				iBufferHeaders.AppendL(bufHdr);

				}

			if (bufCount < iNumBufs)

				{

				iWaitingForBuffers = ETrue;

				}

			}

		}

	}

void CNonTunneledHandler::CPortInfo::SendAllocatedBufferToPeerL(OMX_U8* aBuffer)

	{

	__ASSERT_ALWAYS(iPeer, User::Invariant());

	iPeer->ReceiveAllocatedBufferFromPeerL(aBuffer);

	}

void CNonTunneledHandler::CPortInfo::ReceiveAllocatedBufferFromPeerL(OMX_U8* aBuffer)

	{

	if (iWaitingForBuffers)

		{

		OMX_BUFFERHEADERTYPE* bufHdr = NULL;

		iComp->UseBuffer(iComp, &bufHdr, iPortNum, NULL, iBufSize, aBuffer);

		iBufferHeaders.AppendL(bufHdr);

		if (iBufferHeaders.Count() == iNumBufs)

			{

			iWaitingForBuffers = EFalse;

			}

		}

	else

		{

		iBuffers.AppendL(aBuffer);

		}

	}

void CNonTunneledHandler::CPortInfo::FillBuffers()

	{

	iHoldingBuffers = EFalse;

	if (iSource)

		{

		for (TInt buf = 0; buf < iNumBufs; ++buf)

			{

			iComp->FillThisBuffer(iComp, iBufferHeaders[buf]);

			}

		}

	}

void CNonTunneledHandler::CPortInfo::BufferDone(OMX_BUFFERHEADERTYPE* aBufHdr)

	{

	for (TInt buf = 0; buf < iNumBufs; ++buf)

		{

		if (iBufferHeaders[buf] == aBufHdr)

			{

			iPeer->ReceiveBufferFromPeer(buf, aBufHdr);

			}

		}

	}

void CNonTunneledHandler::CPortInfo::SendBufferToPeer(TInt aBufHdrOffset, OMX_BUFFERHEADERTYPE* aPeerBufHdr)

	{

	__ASSERT_ALWAYS(iPeer, User::Invariant());

	iPeer->ReceiveBufferFromPeer(aBufHdrOffset, aPeerBufHdr);

	}

void CNonTunneledHandler::CPortInfo::ReceiveBufferFromPeer(TInt aBufHdrOffset, OMX_BUFFERHEADERTYPE* aPeerBufHdr)

	{

	__ASSERT_ALWAYS(aBufHdrOffset < iNumBufs, User::Invariant());

	if (!iHoldingBuffers)

		{

		iBufferHeaders[aBufHdrOffset]->nOffset = aPeerBufHdr->nOffset;

		iBufferHeaders[aBufHdrOffset]->nFilledLen = aPeerBufHdr->nFilledLen;

		if (iSource)

			{

			iComp->FillThisBuffer(iComp, iBufferHeaders[aBufHdrOffset]);

			}

		else

			{

			iBufferHeaders[aBufHdrOffset]->hMarkTargetComponent = aPeerBufHdr->hMarkTargetComponent;

			iBufferHeaders[aBufHdrOffset]->pMarkData = aPeerBufHdr->pMarkData;

			iBufferHeaders[aBufHdrOffset]->nTimeStamp = aPeerBufHdr->nTimeStamp;

			iBufferHeaders[aBufHdrOffset]->nFlags = aPeerBufHdr->nFlags;

			if(aPeerBufHdr->nFlags & OMX_BUFFERFLAG_EOS)

                {

                // TODO Logic for EOS

                if(iEosSignalledtoInput == FALSE)

                    {

                    iComp->EmptyThisBuffer(iComp, iBufferHeaders[aBufHdrOffset]);

                    iEosSignalledtoInput = TRUE;

                    }

                return;

                }

			iComp->EmptyThisBuffer(iComp, iBufferHeaders[aBufHdrOffset]);

			}

		}

	}

void CNonTunneledHandler::CPortInfo::HoldBuffers()

	{

	iHoldingBuffers = ETrue;

	}

void CNonTunneledHandler::CPortInfo::FreeBuffers()

	{

	for (TInt buf = 0; buf < iNumBufs; ++buf)

		{

		iComp->FreeBuffer(iComp, iPortNum, iBufferHeaders[buf]);

		}

	DeleteAllBuffers();

	}

void CNonTunneledHandler::CPortInfo::DeleteAllBuffers()

	{

	iBufferHeaders.Reset();

	if (iSource && iSupplier == OMX_BufferSupplyUnspecified)

		{

		iBuffers.ResetAndDestroy();

		}

	else

		{

		iBuffers.Reset();

		}

	}

TBool CNonTunneledHandler::CPortInfo::ComparePortNum(const TInt* aPortNum, const CPortInfo& aPortInfo)

	{

	return (*aPortNum == aPortInfo.iPortNum);

	}