/*

* 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

 @internalComponent

*/

#include "log.h"

#include "omxilgraphicsinkprocessingfunction.h"

#include "omxilgraphicsinktrace.h"

#include "omxilgraphicsinkpanics.h"

#include "omxilgraphicsinkvpb0port.h"

#include <hal.h>

#include <graphics/suerror.h>

#include "omxilgraphicsinkextensionsindexes.h"

#include <openmax/il/shai/OMX_Symbian_ComponentExt.h>

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

// Constant numbers

#ifndef __WINSCW__

const TInt KRefGfxAlignment = RSurfaceManager::EPageAligned;

#else

const TInt KRefGfxAlignment = 2;

#endif

static const TBool KRefGfxContiguous = ETrue;

static const TInt KSurfaceUpdateNumOfMessageSlots = 4;

static const TUint32 KNullTickCount = 0xFFFFFFFF;

/**

Create a new processing function object.

@param 	aCallbacks The callback manager interface for processing function.

@return A pointer to the processing function object to be created.

*/

COmxILGraphicSinkProcessingFunction*

COmxILGraphicSinkProcessingFunction::NewL(MOmxILCallbackNotificationIf& aCallbacks)

	{

	COmxILGraphicSinkProcessingFunction* self =

		new (ELeave)COmxILGraphicSinkProcessingFunction(aCallbacks);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

/**

Second phase construction for the processing function. Loads the device driver for surface manager and initializes the surface attributes.

*/

void

COmxILGraphicSinkProcessingFunction::ConstructL()

	{	

    iTransitionToPauseWait = new(ELeave) CActiveSchedulerWait();

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

    //record the ID of the creator thread for later use

    iOwnerThreadId = RThread().Id();

	iGraphicSurfaceAccess = CGraphicSurfaceAccess::NewL(*this);	        

	iPFHelper = CPFHelper::NewL(*this, *iGraphicSurfaceAccess);

	User::LeaveIfError(iBufferMutex.CreateLocal());

	InitSurfaceAttributes();

    iState = OMX_StateLoaded;

	}

/**

Constructor of the class.

@param 	aCallbacks The callback manager interface for processing function.

*/

COmxILGraphicSinkProcessingFunction::COmxILGraphicSinkProcessingFunction(

		MOmxILCallbackNotificationIf& aCallbacks)

	:

	COmxILProcessingFunction(aCallbacks)

	{

	HAL::Get(HALData::EFastCounterFrequency,iFastCounterFrequency);

	}

/**

Destructor of the class.

*/

COmxILGraphicSinkProcessingFunction::~COmxILGraphicSinkProcessingFunction()

	{

    delete iTransitionToPauseWait;

    iTransitionToPauseWaitSemaphore.Close();

	// Check in case the driver has not been closed. That would happen in

	// an scenario where the component is deleted while being in

	// OMX_StateExecuting state.

	if(iPFHelper &&

	   (iState == OMX_StateInvalid  ||

	    iState == OMX_StateExecuting ||

	    iState == OMX_StatePause))

		{

		// Ignore error if the following call fails

		iPFHelper->StopSync();

		}

	delete iPFHelper;

	delete iGraphicSurfaceAccess;

	iSurfaceManager.Close();

	// Buffer headers are not owned by the processing function

	iBuffersToEmpty.Close();

	iBufferMutex.Close();

	}

/**

This method provides the state change information within the processing function so that appropriate action can be taken. 

This state change information is provided by the FSM on behalf of the IL Client.

@param 	aNewState The new state of FSM.

@return  OMX_ErrorNone if successful

         OMX_ErrorInsufficientResources if fail to start GraphicSink frame acceptor

         OMX_ErrorIncorrectStateTransition if unsupported state

         Any other OpenMAX IL wide error code

*/

OMX_ERRORTYPE

COmxILGraphicSinkProcessingFunction::StateTransitionIndication(TStateIndex aNewState)

	{

	switch(aNewState)

		{

	case EStateExecuting:

		{

		return iPFHelper->ExecuteAsync();

		}

	case EStateInvalid:

		{

		return iPFHelper->StopAsync();

		}

	case EStatePause:

		{

		// must be done immediately

		OMX_ERRORTYPE omxErr = iPFHelper->Pause();

		if(omxErr == OMX_ErrorNone)

			{

			WaitForTransitionToPauseToFinish();

			}

	    return omxErr;

		}

	case EStateIdle:

		{

		iBufferMutex.Wait();

		iBuffersToEmpty.Reset();

		iBufferMutex.Signal();

		iState = OMX_StateIdle;

		return OMX_ErrorNone;

		}

	case EStateLoaded:

	case EStateWaitForResources:

		{

		return iPFHelper->StopAsync();

		}

	case ESubStateLoadedToIdle:

		{

	    // Open a channel to the surface manager logical device driver. 

	    TInt err = iSurfaceManager.Open();

	    if ( err != KErrNone)

	        {

	        return OMX_ErrorHardware;

	        }

	    if (iPFHelper->OpenDevice() != KErrNone)

	        {

            return OMX_ErrorInsufficientResources;

	        }

	    /*

	    if (iGraphicSinkPort->ValidateStride() != OMX_ErrorNone)

	        {

            return OMX_ErrorUnsupportedSetting;

	        }

	    return OMX_ErrorNone;

	    */

	    return iGraphicSinkPort->ValidateStride();

		}

	case ESubStateIdleToLoaded:

		{

		return iPFHelper->CloseDevice();

		}

	case ESubStateExecutingToIdle:

		{

		// must be done immediately

		return iPFHelper->StopAsync();

		}

	case ESubStatePauseToIdle:

		{

		// Ignore these transitions...

		return OMX_ErrorNone;

		}

	default:

		{

		return OMX_ErrorIncorrectStateTransition;

		}

		};

	}

/**

Flushes all the buffers retained by the processing function and sends it to either IL Client or the Tunelled component, as the case may be.

@param 	aPortIndex Port index used to flush buffers from a given port of the component.

@param  aDirection This describes the direction of the port.

@return OMX_ErrorNone if successful;

		Any other OpenMAX IL wide error code;

*/

OMX_ERRORTYPE

COmxILGraphicSinkProcessingFunction::BufferFlushingIndication(

	TUint32 aPortIndex,

	OMX_DIRTYPE aDirection)

	{

	iBufferMutex.Wait();

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

		(aPortIndex == 0 && aDirection == OMX_DirInput))

	{

	    // Send BufferDone notifications for each buffer...

		if(iBufferOnScreen)

			{

			iCallbacks.BufferDoneNotification(iBufferOnScreen, 0, OMX_DirInput);

			iBufferOnScreen = NULL;

			}

		const TUint bufferCount = iBuffersToEmpty.Count();

		OMX_BUFFERHEADERTYPE* pBufferHeader = 0;

		for (TUint i=0; i<bufferCount; i++)

			{

			pBufferHeader = iBuffersToEmpty[i];

			pBufferHeader->nTickCount = KNullTickCount;

			iCallbacks.

				BufferDoneNotification(

					pBufferHeader,

					pBufferHeader->nInputPortIndex,

					OMX_DirInput

					);

			}

		// Empty buffer lists...

		iBuffersToEmpty.Reset();

		iBufferMutex.Signal();

		return OMX_ErrorNone;

	}

	else

		{

		iBufferMutex.Signal();

		return OMX_ErrorBadParameter;

		}

	}

/**

Update the structure corresponding to the given index which belongs to the static parameters list.

@param 	aParamIndex The index representing the desired structure to be updated.

@param  aComponentParameterStructure A pointer to structure which has the desired settings that will be used to update the Processing function.

@return OMX_ErrorNone if successful;

		OMX_ErrorUnsupportedIndex if unsupported index;

		OMX_ErrorUnsupportedSetting if pixel format is EUidPixelFormatUnknown;

		Any other OpenMAX IL wide error code;

*/

OMX_ERRORTYPE

COmxILGraphicSinkProcessingFunction::ParamIndication(

	OMX_INDEXTYPE aParamIndex,

	const TAny* apComponentParameterStructure)

	{

	DEBUG_PRINTF(_L8("COmxILGraphicSinkProcessingFunction::PortParamIndication"));

	switch(aParamIndex)

		{

		case OMX_IndexParamPortDefinition:

			{

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

			//

			// All the fields in SurfaceAttribute structure should be updated.

			//

			iGraphicSurfaceSettings.iSurfaceAttributes.iSize.iWidth = portDefinition->format.video.nFrameWidth;

			iGraphicSurfaceSettings.iSurfaceAttributes.iSize.iHeight = portDefinition->format.video.nFrameHeight;

			// Need to convert OMX Color Format to TUidPixelFormat.

			TUidPixelFormat pixelFormat = ConvertPixelFormat(portDefinition->format.video.eColorFormat);

			if(pixelFormat == EUidPixelFormatUnknown)

				{

                return OMX_ErrorUnsupportedSetting;

				}

			else

				{

                iGraphicSurfaceSettings.iSurfaceAttributes.iPixelFormat = pixelFormat;

				}

			iGraphicSurfaceSettings.iSurfaceAttributes.iBuffers = portDefinition->nBufferCountActual;

			iGraphicSurfaceSettings.iSurfaceAttributes.iStride = portDefinition->format.video.nStride;

			break;

			}

		case OMX_IndexParamVideoPortFormat:

			{

			const OMX_VIDEO_PARAM_PORTFORMATTYPE* videoPortFormat = static_cast<const OMX_VIDEO_PARAM_PORTFORMATTYPE*>(apComponentParameterStructure);

			// only OMX_COLOR_FORMATTYPE eColorFormat to be used for SurfaceAttributes.iPixelFormat		

			TUidPixelFormat pixelFormat = ConvertPixelFormat(videoPortFormat->eColorFormat);

			if(pixelFormat == EUidPixelFormatUnknown)

				{

				return OMX_ErrorUnsupportedSetting;

				}

			else

				{

                iGraphicSurfaceSettings.iSurfaceAttributes.iPixelFormat = pixelFormat;

				}

			break;

			}

		default:

			{

			return OMX_ErrorUnsupportedIndex;

			}

		}

	return OMX_ErrorNone;

	}

/**

Update the structure corresponding to the given index which belongs to the dynamic configuration list.

@param 	aConfigIndex The index representing the desired structure to be updated.

@param  aComponentConfigStructure A pointer to structure which has the desired settings that will be used to update the Processing function.

@return OMX_ErrorNone if successful;

		OMX_ErrorUnsupportedIndex if unsupported index;

		OMX_ErrorUnsupportedSetting if SurfaceConfiguration returns error;

		Any other OpenMAX IL wide error code;

*/

OMX_ERRORTYPE

COmxILGraphicSinkProcessingFunction::ConfigIndication(OMX_INDEXTYPE aConfigIndex,

													  const TAny* apComponentConfigStructure)

	{

	DEBUG_PRINTF(_L8("COmxILGraphicSinkProcessingFunction::ConfigIndication"));

	TInt err = KErrNone;

	switch(aConfigIndex)

		{

	    case OMX_SymbianIndexConfigSharedChunkMetadata:

            {           

            const OMX_SYMBIAN_CONFIG_SHAREDCHUNKMETADATATYPE*

                pSharedChunkMetadata

                = static_cast<

                const OMX_SYMBIAN_CONFIG_SHAREDCHUNKMETADATATYPE*>(

                    apComponentConfigStructure);

            iGraphicSurfaceAccess->iSharedChunkHandleId = pSharedChunkMetadata->nHandleId;

            iGraphicSurfaceAccess->iSharedChunkThreadId = pSharedChunkMetadata->nOwnerThreadId;

            iGraphicSurfaceAccess->iIsLocalChunk = EFalse;

            break;

            }

		case OMX_IndexConfigCommonScale:

			{

			const OMX_CONFIG_SCALEFACTORTYPE* scaleFactor = static_cast<const OMX_CONFIG_SCALEFACTORTYPE*>(apComponentConfigStructure);

			err = iGraphicSurfaceSettings.iSurfaceConfig.SetExtent(TRect(TSize(scaleFactor->xWidth, scaleFactor->xHeight)));

			if(err != KErrNone)

				{

				return OMX_ErrorUnsupportedSetting;

				}

			break;

			}

		case OMX_IndexConfigCommonOutputSize:

			{

			const OMX_FRAMESIZETYPE* frameSize = static_cast<const OMX_FRAMESIZETYPE*>(apComponentConfigStructure);

			err = iGraphicSurfaceSettings.iSurfaceConfig.SetExtent(TRect(TSize(frameSize->nWidth, frameSize->nHeight)));

			if(err != KErrNone)

				{

				return OMX_ErrorUnsupportedSetting;

				}

			break;

			}

		case OMX_IndexConfigCommonInputCrop:

		case OMX_IndexConfigCommonOutputCrop:

		case OMX_IndexConfigCommonExclusionRect:

			{

			const OMX_CONFIG_RECTTYPE* rec = static_cast<const OMX_CONFIG_RECTTYPE*>(apComponentConfigStructure);

			err = iGraphicSurfaceSettings.iSurfaceConfig.SetExtent(TRect(TPoint(rec->nTop, rec->nLeft), TSize(rec->nWidth, rec->nHeight)));

			if(err != KErrNone)

				{

				return OMX_ErrorUnsupportedSetting;

				}

			break;

			}

		default:

			{

			return OMX_ErrorUnsupportedIndex;

			}

		}

	return OMX_ErrorNone;

	}

void COmxILGraphicSinkProcessingFunction::SetSharedChunkBufConfig(TMMSharedChunkBufConfig aSharedChunkBufConfig)

    {

    iGraphicSurfaceAccess->iSharedChunkBufConfig = aSharedChunkBufConfig;

    }

void COmxILGraphicSinkProcessingFunction::GetSharedChunkMetadata(

    OMX_U32& aHandleId,

    OMX_U64& aThreadId) const

    {

    aHandleId = iGraphicSurfaceAccess->iSharedChunkHandleId;

    aThreadId = iGraphicSurfaceAccess->iSharedChunkThreadId;

    }

/**

This method is invoked whenever the component is requested to emtpy/display the contents of the buffers passed as function arguments.

@param 	apBufferHeader A pointer to buffer header.

@param  aDirection provides the direction either input or output. This can be used as a further check whether buffers received are valid or not.

@return OMX_ErrorNone if successful;

		Any other OpenMAX IL wide error code;

*/

OMX_ERRORTYPE

COmxILGraphicSinkProcessingFunction::BufferIndication(

	OMX_BUFFERHEADERTYPE* apBufferHeader,

	OMX_DIRTYPE aDirection)

	{

    if (aDirection != OMX_DirInput)

        {

        return OMX_ErrorBadParameter;

        }

    //The nTickCount is just internal here, stored temporarily. So it is count not time period.

    apBufferHeader->nTickCount = User::FastCounter();

    iBufferMutex.Wait();

    OMX_ERRORTYPE ret = OMX_ErrorNone;

    if (iBuffersToEmpty.Append(apBufferHeader) != KErrNone)

        {

        apBufferHeader->nTickCount = KNullTickCount;

        ret = OMX_ErrorInsufficientResources;

        }

    else if (iState != OMX_StateExecuting)

        {

        // If Component not in an executing state delay processing buffer

        ret = OMX_ErrorNone;

        }

    else if (iPFHelper->BufferIndication() != KErrNone)

        {

        apBufferHeader->nTickCount = KNullTickCount;

        ret = OMX_ErrorInsufficientResources;

        }

    iBufferMutex.Signal();

    return ret;

	}

/**

This method is used to check whether the required buffer is held by the processing function or not.

@param 	apBufferHeader A pointer to buffer header being searched.

@param  aDirection provides the direction either input or output. This can be used as a further check whether buffers received are valid or not.

@return OMX_TRUE if find the buffer;

		OMX_FALSE if fail to find the buffer;

*/

OMX_BOOL

COmxILGraphicSinkProcessingFunction::BufferRemovalIndication(

	OMX_BUFFERHEADERTYPE* apBufferHeader,

	OMX_DIRTYPE /* aDirection */)

	{

    TBool headerDeletionResult = ETrue;

	TInt headerIndexInArray = KErrNotFound;

	iBufferMutex.Wait();

	if (KErrNotFound !=

		(headerIndexInArray =

		 iBuffersToEmpty.Find(apBufferHeader)))

		{

		iBuffersToEmpty.Remove(headerIndexInArray);

		}

	else if(iBufferOnScreen == apBufferHeader)

		{

		iBufferOnScreen = NULL;

		}

	else

		{

		headerDeletionResult = EFalse;

		}

	iBufferMutex.Signal();

    return (headerDeletionResult ? OMX_TRUE : OMX_FALSE);

	}

/**

This method creates COmxILMMBuffer class object. Also creates surface and allocates the chunks based on the number of buffers, 

maps the surface in the given process. It also allocates the resources like creating the message queue and other necessary C 

class objects. This method gets called when the component acts as buffer supplier.

@param 	aPortSpecificBuffer gives the starting address of the specific buffer.

@param  aPortPrivate gives the private data which is COmxILMMBuffer pointer in this case.

@leave  OMX_ErrorNone if successful;

@leave  OMX_ErrorInsufficientResources if function returns KErrNoMemory;

@leave  OMX_ErrorBadParameter if function returns errors except KErrNoMemory;

@leave  Any other OpenMAX IL wide error code;

*/

void COmxILGraphicSinkProcessingFunction::CreateBufferL(OMX_U8*& aPortSpecificBuffer, OMX_PTR& aPortPrivate, OMX_U32 aBufferCountActual)

	{

	iGraphicSurfaceAccess->CreateBufferL(aPortSpecificBuffer, aPortPrivate, aBufferCountActual);

	}

/**

Destroy MM buffer, close surface, and deallocate other resources like message queue and C class objects. This is called when component

acts as buffer supplier.