/*

* Copyright (c) 2008-2010 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 <openmax/il/common/omxilconfigmanager.h>

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

#include "omxilgraphicsink.h"

#include "omxilgraphicsinkvpb0port.h"

#include "omxilgraphicsinkprocessingfunction.h"

#include "omxilgraphicsink.hrh"

#include <openmax/il/loader/omxilsymbiancomponentif.h>

#include "log.h"

_LIT8(KSymbianOMXGraphicSinkComponentName, KCompNameSymbianOMXGraphicSink);

_LIT8(KSymbianOMXGraphicSinkRole, KRoleSymbianOMXGraphicSink);

const TUint8 COmxILGraphicSink::iComponentVersionMajor;

const TUint8 COmxILGraphicSink::iComponentVersionMinor;

const TUint8 COmxILGraphicSink::iComponentVersionRevision;

const TUint8 COmxILGraphicSink::iComponentVersionStep;

OMXIL_COMPONENT_ECOM_ENTRYPOINT(KUidSymbianOmxILGraphicSink);

/**

Component Entry Point

@param aComponent The handle of the component to be initialised.

@return KErrNone if successful;

        KErrNoMemory if the driver failed to allocate memory for the new component;

        otherwise one of the other system-wide error codes.

*/

OMX_ERRORTYPE OMX_ComponentInit(OMX_HANDLETYPE aComponent)

	{

	TInt err = COmxILGraphicSink::CreateComponent(aComponent);

	if (err == KErrNone)

		{

		return OMX_ErrorNone;

		}

	else

		{

		// return some problem

		return err == KErrNoMemory ? OMX_ErrorInsufficientResources : OMX_ErrorUndefined;

		}

	}

/**

This function creates a new Graphic sink component.

@param aComponent The handle of the component to be created.

@return KErrNone if successful;

        KErrNoMemory if the driver failed to allocate memory for the new component;

        otherwise one of the other system-wide error codes.

*/

TInt COmxILGraphicSink::CreateComponent(OMX_HANDLETYPE aComponent)

	{

    DEBUG_PRINTF(_L8("COmxILGraphicSink::CreateComponent"));

    COmxILGraphicSink* self = new COmxILGraphicSink();

	if (!self)

		{

		return KErrNoMemory;

		}

	TRAPD(err, self->ConstructL(aComponent));

	if(err != KErrNone)

		{

		delete self;

		}

	return err;

	}

/**

Constructor of the class.

*/

COmxILGraphicSink::COmxILGraphicSink()

	{

	DEBUG_PRINTF(_L8("COmxILGraphicSink::COmxILGraphicSink +"));

	}

/**

Destructor of the class.

*/

COmxILGraphicSink::~COmxILGraphicSink()

	{

	DEBUG_PRINTF(_L8("COmxILGraphicSink::~COmxILGraphicSink +"));

	}

/**

Second phase construction for the component.

@param aHandle The handle of the component to be created.

*/

void COmxILGraphicSink::ConstructL(OMX_HANDLETYPE aHandle)

	{

	DEBUG_PRINTF(_L8("COmxILGraphicSink::ConstructL"));

	// Initialize the data received from IL Core

	COmxILComponent::ConstructL(aHandle);

	// STEP 2: Create the call backs manager...

	MOmxILCallbackNotificationIf* callbackNotificationIf=CreateCallbackManagerL(COmxILComponent::EOutofContext);

	// STEP 3: Create the Graphic Sink Processing Function...

	COmxILGraphicSinkProcessingFunction* pGraphicSinkProcessingFunction = COmxILGraphicSinkProcessingFunction::NewL(*callbackNotificationIf);

	RegisterProcessingFunction(pGraphicSinkProcessingFunction);

	// STEP 4: Create Port manager...

	CreatePortManagerL(COmxILComponent::ENonBufferSharingPortManager,

		TOmxILSpecVersion(),	// OMX Version

		0, 						// The number of audio ports in this component

		0,						// The starting audio port index

		0,						// The number of image ports in this component

		0,						// The starting image port index

		1,						// The number of video ports in this component

		0,						// The starting video port index

		0,						// The number of other ports in this component

		0						// The starting other port index

		);

	COmxILGraphicSinkVPB0Port* pb0Port = ConstructVPB0PortL();

	CleanupStack::PushL(pb0Port);

	User::LeaveIfError(AddPort(pb0Port, OMX_DirInput));

	CleanupStack::Pop(pb0Port);

	SetPortToPF(pb0Port);

	// STEP 5: Create the non-port related configuration manager...

	RPointerArray<TDesC8> componentRoles;

	CleanupClosePushL(componentRoles);

	componentRoles.AppendL(&KSymbianOMXGraphicSinkRole);

	COmxILConfigManager* pConfigManager = COmxILConfigManager::NewL(

                                            KSymbianOMXGraphicSinkComponentName,

                                            TOmxILVersion(iComponentVersionMajor,

                                                          iComponentVersionMinor,

                                                          iComponentVersionRevision,

                                                          iComponentVersionStep),

                                            componentRoles);

	CleanupStack::PopAndDestroy(&componentRoles);

	RegisterConfigurationManager(pConfigManager);

	// And finally, let's get everything started

	InitComponentL();

	}

/**

Create the input port VPB0Port for Graphic sink.

@return A pointer to the VPB0Port to be created.

*/

COmxILGraphicSinkVPB0Port* COmxILGraphicSink::ConstructVPB0PortL()

	{

	DEBUG_PRINTF(_L8("COmxILGraphicSink::ConstructVPB0PortL +"));

	OMX_U32 thisPortIndex = 0;

	const TUint32  KBufferCountMin = 2;  	// OMX_U32

	const TUint32  KBufferSizeMin = 1024; 	// OMX_U32

#ifndef ILCOMPONENTCONFORMANCE

	const TUint32  KBufferAlignment = 2;		// OMX_U32

	const OMX_BOOL KBuffersContiguous = OMX_TRUE;

#else

	// conformance suite currently doesn't support allocating contiguous or

	// beyond byte aligned buffers

	const TUint32  KBufferAlignment = 0;		// OMX_U32

	const OMX_BOOL KBuffersContiguous = OMX_FALSE;

#endif

	// These arrays must left empty, to be removed from the video port constructor

	RArray<OMX_VIDEO_CODINGTYPE> supportedVideoFormats;

	RArray<OMX_COLOR_FORMATTYPE> supportedColorFormats;

	CleanupClosePushL(supportedVideoFormats);

	CleanupClosePushL(supportedColorFormats);

	COmxILGraphicSinkVPB0Port* vpb0Port = COmxILGraphicSinkVPB0Port::NewL(

		TOmxILCommonPortData(

			TOmxILSpecVersion(),// OMX specification version information

			thisPortIndex,		// Port number the structure applies to

			OMX_DirInput,		// Direction of this port

			KBufferCountMin,		// The minimum number of buffers this port requires

			KBufferSizeMin,		// Minimum size, in bytes, for buffers to be used for this port

			OMX_PortDomainVideo,// Domain of the port

			KBuffersContiguous,	// Buffers contiguous requirement (true or false)

			KBufferAlignment,	// Buffer aligment requirements

			OMX_BufferSupplyInput,	// supplier preference when tunneling between two ports

			COmxILPort::KBufferMarkPropagationPortNotNeeded

			),

		supportedVideoFormats,	// Supported video formats

		supportedColorFormats,	// Supported color formats

		*((COmxILGraphicSinkProcessingFunction *)(GetProcessingFunction()))

		);

	CleanupStack::PopAndDestroy(2, &supportedVideoFormats);

	return vpb0Port;

	}

/*

Set the graphic sink port to the graphic sink processing function, 

so the processing function can access the port definition later.

 */

void COmxILGraphicSink::SetPortToPF(COmxILGraphicSinkVPB0Port* aPort)

   {

    ((COmxILGraphicSinkProcessingFunction *)(GetProcessingFunction()))->iGraphicSinkPort = aPort;

   }