// Copyright (c) 2008-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:

//

/**

 * @file

 * @internalTechnology

 */

#include <uri8.h>

#include <openmax/il/common/omxilcallbacknotificationif.h>

#include "omxilfilesourceprocessingfunction.h"

const TInt KMaxMsgQueueEntries = 25;

// This represents the number of times this component will respond to a client when the file handle is invalid

// (e.g a URI is not specified) before sending a OMX_BUFFERFLAG_EOS notification flag. This is to prevent

// the endless buffer passing. 250 is chosen as it is more than the number of buffers passed by Khronos conformance

// suite during port communication test.

const TInt KMaxBuffersWhenNoFileName =250; 

const TInt KBufferSizeReturnedWhenNoFileName = 2;

COmxILFileSourceProcessingFunction* COmxILFileSourceProcessingFunction::NewL(MOmxILCallbackNotificationIf& aCallbacks)

	{

	COmxILFileSourceProcessingFunction* self = new (ELeave) COmxILFileSourceProcessingFunction(aCallbacks);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

COmxILFileSourceProcessingFunction::COmxILFileSourceProcessingFunction(MOmxILCallbackNotificationIf& aCallbacks)

: COmxILProcessingFunction(aCallbacks)

	{

	}

void COmxILFileSourceProcessingFunction::ConstructL()

	{

	iState = OMX_StateLoaded;

	ipFileSourceAccess = CFileSourceAccess::NewL(*this);

	ipBufferArrivalHandler = CBufferArrivalHandler::NewL(*this, *ipFileSourceAccess);

	ipPFHelper = CPFHelper::NewL(*this, *ipFileSourceAccess, *ipBufferArrivalHandler);

	}

COmxILFileSourceProcessingFunction::~COmxILFileSourceProcessingFunction()

	{

	if(ipPFHelper &&

	   (iState == OMX_StateInvalid  ||

	    iState == OMX_StateExecuting ||

	    iState == OMX_StatePause))

		{

		ipPFHelper->StopSync();

		}

	delete ipBufferArrivalHandler;

	delete ipPFHelper;

	delete ipFileSourceAccess;

	delete ipUri;

	delete ipFileName;

	// Buffer headers are not owned by the processing function

    iBuffersToFill.Close();

	}

OMX_ERRORTYPE COmxILFileSourceProcessingFunction::StateTransitionIndication(TStateIndex aNewState)

	{

	OMX_ERRORTYPE err = OMX_ErrorNone;

	switch(aNewState)

		{

		case EStateExecuting:

			{

			if (ipPFHelper->ExecuteAsync() != KErrNone)

				{

				err = OMX_ErrorInsufficientResources;

				}

			}

			break;

		case EStateInvalid:

			{

            if (ipPFHelper && ipPFHelper->StopAsync() != KErrNone)

                {

                err = OMX_ErrorInsufficientResources;

                }

			}

			break;

		case EStatePause:

			{

			ipPFHelper->PauseAsync();

			}

			break;

		case EStateIdle:

			{

			ipPFHelper->IdleAsync();

			}

			break;

		case EStateLoaded:

		case EStateWaitForResources:

			{

			if (ipPFHelper && ipPFHelper->StopAsync() != KErrNone)

				{

				err = OMX_ErrorInsufficientResources;

				}

			}

			break;

		case ESubStateExecutingToIdle:

			{

			ipPFHelper->StopAsync();

			}

			break;

		case ESubStatePauseToIdle:

	    case ESubStateLoadedToIdle:

	    case ESubStateIdleToLoaded:

			break;

		default:

			{

			err = OMX_ErrorIncorrectStateTransition;

			}

		};

	return err;

	}

OMX_ERRORTYPE COmxILFileSourceProcessingFunction::BufferFlushingIndication(TUint32 aPortIndex, OMX_DIRTYPE aDirection)

	{

    OMX_ERRORTYPE err = OMX_ErrorNone;

    if ((aPortIndex == OMX_ALL && aDirection == OMX_DirMax) ||

        (aPortIndex == 0 && aDirection == OMX_DirOutput))

        {

        err = CPFHelper::ConvertSymbianErrorType(ipPFHelper->FlushIndication());

        }

    else

        {

        err = OMX_ErrorBadParameter;

        }

    return err;

    }

OMX_ERRORTYPE COmxILFileSourceProcessingFunction::ParamIndication(OMX_INDEXTYPE aParamIndex, const TAny* apComponentParameterStructure)

	{

	OMX_ERRORTYPE err = OMX_ErrorNone;

	switch(aParamIndex)

		{

		case OMX_IndexParamPortDefinition:

			{

			//const OMX_PARAM_PORTDEFINITIONTYPE* portDefinition = static_cast<const OMX_PARAM_PORTDEFINITIONTYPE*>(apComponentParameterStructure);

			//nothing to do

			//

			//the number of buffers may change depending on capture mode (single shot vs burst mode)

			//in that case, we need to do something for PF...

			break;

			}

		case OMX_IndexParamContentURI:

			{

			const OMX_PARAM_CONTENTURITYPE* contentUriType = reinterpret_cast<const OMX_PARAM_CONTENTURITYPE*>(apComponentParameterStructure);

			err = SetFileName(contentUriType);

			break;

			}

		default:

			{

			err = OMX_ErrorUnsupportedIndex;

			}

		}

	return err;

	}

OMX_ERRORTYPE COmxILFileSourceProcessingFunction::ConfigIndication(OMX_INDEXTYPE /*aConfigIndex*/, const TAny* /*apComponentConfigStructure*/)

	{

	return OMX_ErrorNone;

	}

OMX_ERRORTYPE COmxILFileSourceProcessingFunction::BufferIndication(OMX_BUFFERHEADERTYPE* apBufferHeader, OMX_DIRTYPE aDirection)

	{

	if (aDirection == OMX_DirOutput)

    	{

    	if (ipBufferArrivalHandler->BufferIndication(apBufferHeader) != KErrNone)

    		{

    		return OMX_ErrorInsufficientResources;

    		}

		}

    else

    	{

    	return OMX_ErrorBadParameter;

    	}

    return OMX_ErrorNone;

	}

OMX_BOOL COmxILFileSourceProcessingFunction::BufferRemovalIndication(OMX_BUFFERHEADERTYPE* apBufferHeader, OMX_DIRTYPE /*aDirection*/)

	{

	return ipPFHelper->RemoveBufferIndication(apBufferHeader);

	}

MOmxILCallbackNotificationIf& COmxILFileSourceProcessingFunction::GetCallbacks()

	{

	return iCallbacks;

	}

OMX_ERRORTYPE COmxILFileSourceProcessingFunction::SetFileName(const OMX_PARAM_CONTENTURITYPE* aContentUriType)

	{

	ASSERT(aContentUriType);

	delete ipFileName;

	ipFileName = NULL;

	delete ipUri;

	ipUri = NULL;

	TInt sizeOfUri = aContentUriType->nSize - _FOFF(OMX_PARAM_CONTENTURITYPE, contentURI); //Actual size of URI

	if (sizeOfUri <= 0)

		{

		return OMX_ErrorBadParameter;

		}

	// Don't include the zero character at the end.

	TPtrC8 uriDes(aContentUriType->contentURI,sizeOfUri);

	TInt err = KErrNone;

	do

		{

		TUriParser8 parser;

		err = parser.Parse(uriDes);

		if (err != KErrNone)

			{

			break;

			}

		TRAP(err, ipFileName = parser.GetFileNameL());

		if (err != KErrNone)

			{

			break;

			}

		// Remove Null charcter '\0' if any.

		TPtr filePtr(ipFileName->Des());

		TInt index = filePtr.LocateReverse('\0');

		if (index != KErrNotFound && index == filePtr.Length()-1)

		    {

		    filePtr.Delete(index,1);

		    }

		uriDes.Set(reinterpret_cast<const TUint8 *>(aContentUriType), aContentUriType->nSize );

        ipUri = uriDes.Alloc();

        if (!ipUri)

            {

            err = KErrNoMemory;

            break;

            }

		return OMX_ErrorNone;

		}

	while (EFalse);

	// Something failed.

	__ASSERT_DEBUG( (err == KErrNone), User::Panic(_L("UriParsing"), err) );

	delete ipFileName;

	ipFileName = NULL;

	delete ipUri;

	ipUri = NULL;

	return (err == KErrNoMemory ? OMX_ErrorInsufficientResources : OMX_ErrorBadParameter);

	}

const HBufC* COmxILFileSourceProcessingFunction::FileName() const

	{

	return ipFileName;

	}

const HBufC8* COmxILFileSourceProcessingFunction::Uri() const

	{

	return ipUri;

	}

COmxILFileSourceProcessingFunction::CFileSourceAccess* COmxILFileSourceProcessingFunction::CFileSourceAccess::NewL(COmxILFileSourceProcessingFunction& aParent)

	{

	CFileSourceAccess* self = new (ELeave) CFileSourceAccess(aParent);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

COmxILFileSourceProcessingFunction::CFileSourceAccess::CFileSourceAccess(COmxILFileSourceProcessingFunction& aParent)

	: CActive(EPriorityStandard),

	iParent(aParent),

	iBufferOffset(0),

	iReadBuffer(0,0),

	iEOSFlag(EFalse)

	{

	CActiveScheduler::Add(this);

	}

void COmxILFileSourceProcessingFunction::CFileSourceAccess::ConstructL()

	{

	User::LeaveIfError(iFs.Connect());

	}

COmxILFileSourceProcessingFunction::CFileSourceAccess::~CFileSourceAccess()

	{

	Cancel();

	iFileHandle.Close();

	iFs.Close();

	}

void COmxILFileSourceProcessingFunction::CFileSourceAccess::RunL()

	{

	// The buffer is not on the list implies that they have already been flushed/spotted

	// via BufferFlushingIndication/BufferRemovalIndication

	TInt index = iParent.iBuffersToFill.Find(iCurrentBuffer);

	if (KErrNotFound != index)

		{

		switch(iStatus.Int())

			{

			case KErrNone:

				{

				if (iReadBuffer.Length()==0) //the end of the file

				    {

				    iFileHandle.Close();

				    iCurrentBuffer->nFlags |= OMX_BUFFERFLAG_EOS;

				    iParent.GetCallbacks().EventNotification(OMX_EventBufferFlag, iCurrentBuffer->nOutputPortIndex, OMX_BUFFERFLAG_EOS, NULL);

				    iEOSFlag = ETrue;

				    }

				iCurrentBuffer->nFilledLen=iReadBuffer.Length();

				iCurrentBuffer->nOffset = 0;

				break;

				}

			default:

				{

				User::Leave(iStatus.Int());

				}

			};

		iParent.GetCallbacks().BufferDoneNotification(iCurrentBuffer,iCurrentBuffer->nOutputPortIndex,OMX_DirOutput);

		iParent.iBuffersToFill.Remove(index);

		iCurrentBuffer = NULL;

		}

    if(iFileHandle.SubSessionHandle() != 0)

        {

        ProcessNextBuffer();

        }

	}

TInt COmxILFileSourceProcessingFunction::CFileSourceAccess::ProcessNextBuffer()

	{

	TInt err = KErrNone;

	if ((iParent.iBuffersToFill.Count() > 0) && !IsActive() && iParent.iState == OMX_StateExecuting)

		{

		iCurrentBuffer = iParent.iBuffersToFill[0];

		iReadBuffer.Set(iCurrentBuffer->pBuffer, iCurrentBuffer->nAllocLen, iCurrentBuffer->nAllocLen);

        if (iFileHandle.SubSessionHandle() == 0)

            {

            if(iEOSFlag == EFalse)

                {

                // This condition caters for when an IL client does not set the URI before trasitioning to 

                // executing state (like the Khronos conformance suite). The proposed way to deal with this is to keep

                // sending BufferDone notification with blank buffers with size >0 for KMaxBuffersWhenNoFileName number

                // of times before OMX_BUFFERFLAG_EOS flag is sent to client. This simulates a normal communication.

                if( iEOSBufferNotificationCount <= KMaxBuffersWhenNoFileName )

                    {

                    TUint nBufferSize = 0;

                    if (iEOSBufferNotificationCount < KMaxBuffersWhenNoFileName)

                        {

                        nBufferSize = KBufferSizeReturnedWhenNoFileName;

                        }

                    iReadBuffer.Set(iCurrentBuffer->pBuffer, nBufferSize, iCurrentBuffer->nAllocLen);                  

                    iEOSBufferNotificationCount++;              

                    SetActive();

                    TRequestStatus* status(&iStatus);

                    User::RequestComplete(status, KErrNone);

                    }

                }

            else

                {

                iReadBuffer.Set(iCurrentBuffer->pBuffer, iCurrentBuffer->nAllocLen, iCurrentBuffer->nAllocLen);

                // do nothing. this menas that all operations have completed succesfully.

                }

            }

        else

            {

            iFileHandle.Read(iReadBuffer, iCurrentBuffer->nAllocLen, iStatus);

            SetActive();

            }

		}

	return err;

	}

void COmxILFileSourceProcessingFunction::CFileSourceAccess::DoCancel()

	{

	if (iFileHandle.SubSessionHandle() != 0)

	    {

	    iFileHandle.Close();

	    }

	iEOSFlag = EFalse;

	iEOSBufferNotificationCount = 0;

	iCurrentBuffer = NULL;

	}

TInt COmxILFileSourceProcessingFunction::CFileSourceAccess::Execute()

	{

	iEOSFlag = EFalse;

	iEOSBufferNotificationCount = 0;

	iParent.iState = OMX_StateExecuting;

	return ProcessNextBuffer();

	}

void COmxILFileSourceProcessingFunction::CFileSourceAccess::Pause()

	{

	iParent.iState = OMX_StatePause;

	}

void COmxILFileSourceProcessingFunction::CFileSourceAccess::Idle()

    {

    iParent.iState = OMX_StateIdle;

    iParent.iBuffersToFill.Reset();

    }

void COmxILFileSourceProcessingFunction::CFileSourceAccess::CancelDataTransfer()

    {

    if(iFileHandle.SubSessionHandle() != 0)

        {

        iFileHandle.ReadCancel();

        }

    }

void COmxILFileSourceProcessingFunction::CFileSourceAccess::Stop()

	{

	if(iParent.iState == OMX_StateExecuting || iParent.iState == OMX_StatePause)

		{

		Cancel();

		iParent.iState = OMX_StateIdle;

		}

	}

COmxILFileSourceProcessingFunction::CPFHelper* COmxILFileSourceProcessingFunction::CPFHelper::NewL(COmxILFileSourceProcessingFunction& aParent, CFileSourceAccess& aFileSourceAccess, CBufferArrivalHandler& aBufferArrivalHandler)

	{

	CPFHelper* self = new (ELeave) CPFHelper(aParent, aFileSourceAccess, aBufferArrivalHandler);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

COmxILFileSourceProcessingFunction::CPFHelper::CPFHelper(COmxILFileSourceProcessingFunction& aParent, CFileSourceAccess& aFileSourceAccess, CBufferArrivalHandler& aBufferArrivalHandler)

: CActive(CActive::EPriorityUserInput),

  iParent(aParent),

  iFileSourceAccess(aFileSourceAccess),

  iBufferArrivalHandler(aBufferArrivalHandler)

	{

	CActiveScheduler::Add(this);

    iRunLContext = RThread();

	}

void COmxILFileSourceProcessingFunction::CPFHelper::ConstructL()

	{

    User::LeaveIfError(iWaitSemaphore.CreateLocal(0));

	User::LeaveIfError(iMsgQueue.CreateLocal(KMaxMsgQueueEntries));

	SetActive();

	iMsgQueue.NotifyDataAvailable(iStatus);

	}

COmxILFileSourceProcessingFunction::CPFHelper::~CPFHelper()

	{

	Cancel();

	iMsgQueue.Close();

    iRunLContext.Close();

    iWaitSemaphore.Close();

	}

void COmxILFileSourceProcessingFunction::CPFHelper::RunL()

	{

	TInt err = ProcessQueue();

	if (err != KErrNone)

		{

		iParent.GetCallbacks().ErrorEventNotification( ConvertSymbianErrorType(err) );

		}

	// setup for next callbacks

	SetActive();

	iMsgQueue.NotifyDataAvailable(iStatus);

	}

void COmxILFileSourceProcessingFunction::CPFHelper::DoCancel()

	{

	if (iMsgQueue.Handle())

		{

		ProcessQueue();

		iMsgQueue.CancelDataAvailable();

		}

	}

TInt COmxILFileSourceProcessingFunction::CPFHelper::ProcessQueue()

	{

	TProcMessage msg;

	TInt err = KErrNone;

	while (iMsgQueue.Receive(msg) == KErrNone)

		{

		switch (msg.iType)

			{

			case EExecuteCommand:

				{

                const HBufC* fileName = iParent.FileName();

	            if (fileName && iFileSourceAccess.iFileHandle.SubSessionHandle() == 0)

                    {

                    err = iFileSourceAccess.iFileHandle.Open(iFileSourceAccess.iFs, *fileName, EFileRead | EFileShareReadersOnly);

                    }

	            // Transition to execute only when opening the file succeeds or there is no file name at all

                if ( err == KErrNone)