/*

* 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:

*

*/

/**

@file

@internalComponent

*/

#include "buffercopier.h"

_LIT(KBufferCopierPanic, "CBufferCopier");

CBufferCopier* CBufferCopier::NewL(MBufferCopierIf& aCallback, TInt aMaxBuffers)

	{

	CBufferCopier* self = new(ELeave) CBufferCopier(aCallback);

	CleanupStack::PushL(self);

	self->ConstructL(aMaxBuffers);

	CleanupStack::Pop(self);

	return self;

	}

CBufferCopier::CBufferCopier(MBufferCopierIf& aCallback):

CActive(EPriorityNormal),

iCallback(aCallback)

	{

	CActiveScheduler::Add(this);

	}

void CBufferCopier::ConstructL(TInt aMaxBuffers)

	{

	User::LeaveIfError(iInQueue.CreateLocal(aMaxBuffers));

	User::LeaveIfError(iOutQueue.CreateLocal(aMaxBuffers));

	User::LeaveIfError(iRemoveQueue.CreateLocal(aMaxBuffers));

	SetActive();

	iInQueue.NotifyDataAvailable(iStatus);

	}

CBufferCopier::~CBufferCopier()

	{

	Cancel();

	iInQueue.Close();

	iOutQueue.Close();

	iRemoveQueue.Close();

	}

void CBufferCopier::DeliverBuffer(OMX_BUFFERHEADERTYPE* aBuffer, OMX_DIRTYPE aDirection)

	{

	RMsgQueue<OMX_BUFFERHEADERTYPE*>& queue = aDirection == OMX_DirInput ? iInQueue : iOutQueue;

	TInt err = queue.Send(aBuffer);

	// do not expect error as maximum buffer count already allocated

	if(err != KErrNone)

		{

		User::Panic(KBufferCopierPanic, err);

		}

	}

void CBufferCopier::RunL()

	{

	if(iInBuffer == NULL)

		{

		// ignore error, if KErrUnderflow then we go back to waiting on iInQueue

		iInQueue.Receive(iInBuffer);

		}

	else

		{

		OMX_BUFFERHEADERTYPE* outBuffer = NULL;

		TInt err = iOutQueue.Receive(outBuffer);

		// if KErrUnderflow then we go back to waiting on iOutQueue

		if(err == KErrNone)

			{

			CopyBuffer(iInBuffer, outBuffer);

			iInBuffer = NULL;

			}

		}

	SetActive();

	if(iInBuffer == NULL)

		{

		iInQueue.NotifyDataAvailable(iStatus);

		}

	else

		{

		iOutQueue.NotifyDataAvailable(iStatus);

		}

	}

void CBufferCopier::DoCancel()

	{

	iInQueue.CancelDataAvailable();

	iOutQueue.CancelDataAvailable();

	}

void CBufferCopier::CopyBuffer(OMX_BUFFERHEADERTYPE* aInBuffer, OMX_BUFFERHEADERTYPE* aOutBuffer)

	{

	aOutBuffer->nOffset = 0;

	TPtr8 desPtr(aOutBuffer->pBuffer, aOutBuffer->nAllocLen);

 	desPtr.Copy(aInBuffer->pBuffer + aInBuffer->nOffset, aInBuffer->nFilledLen);

	aOutBuffer->nFilledLen			 = aInBuffer->nFilledLen;

	aOutBuffer->hMarkTargetComponent = aInBuffer->hMarkTargetComponent;

	aOutBuffer->pMarkData			 = aInBuffer->pMarkData;

	aOutBuffer->nTickCount			 = aInBuffer->nTickCount;

	aOutBuffer->nTimeStamp			 = aInBuffer->nTimeStamp;

	aOutBuffer->nFlags				 = aInBuffer->nFlags;			

	iCallback.MbcBufferCopied(aInBuffer, aOutBuffer);

	}

TBool CBufferCopier::RemoveBuffer(OMX_BUFFERHEADERTYPE* aBuffer, OMX_DIRTYPE aDirection)

	{

	switch(aDirection)

		{

	case OMX_DirInput:

		{

		if(aBuffer == iInBuffer)

			{

			// also check the slot used for storing the input buffer when waiting for an output buffer

			iInBuffer = NULL;

			return ETrue;

			}

		else

			{

			return RemoveFromQueue(iInQueue, aBuffer);

			}

		}

	case OMX_DirOutput:

		return RemoveFromQueue(iOutQueue, aBuffer);

	default:

		User::Panic(KBufferCopierPanic, KErrArgument);

		return EFalse;	// prevent compiler warning

		}

	}

void CBufferCopier::FlushBuffers(OMX_DIRTYPE aDirection)

	{

	OMX_BUFFERHEADERTYPE* buffer;

	if(aDirection == OMX_DirInput)

		{

        if(iInBuffer)

            {

            iCallback.MbcBufferFlushed(iInBuffer, OMX_DirInput);

            iInBuffer = NULL;

            }

		while(iInQueue.Receive(buffer) != KErrUnderflow)

			{

			iCallback.MbcBufferFlushed(buffer, OMX_DirInput);

			}

		}

	else if(aDirection == OMX_DirOutput)

		{

		while(iOutQueue.Receive(buffer) != KErrUnderflow)

			{

			iCallback.MbcBufferFlushed(buffer, OMX_DirOutput);

			}

		}

	else

		{

		User::Panic(KBufferCopierPanic, KErrArgument);

		}

	}

TBool CBufferCopier::RemoveFromQueue(RMsgQueue<OMX_BUFFERHEADERTYPE*>& aQueue, OMX_BUFFERHEADERTYPE* aBufferHeader)

	{

	TBool removed = EFalse;

	OMX_BUFFERHEADERTYPE* bufferHeader = NULL;

	while(aQueue.Receive(bufferHeader) != KErrUnderflow)

		{

		if(bufferHeader != aBufferHeader)

			{

			TInt err = iRemoveQueue.Send(bufferHeader);

			__ASSERT_DEBUG(err == KErrNone, User::Panic(KBufferCopierPanic, err));

			}

		else

			{

			removed = ETrue;

			}

		}

	while(iRemoveQueue.Receive(bufferHeader) != KErrUnderflow)

		{

		TInt err = aQueue.Send(bufferHeader);

		__ASSERT_DEBUG(err == KErrNone, User::Panic(KBufferCopierPanic, err));

		}

	return removed;

	}