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

//

#include "omxilgenericilif.h"

#include "omxilgenericilifbody.h"

#include "omxilcoreutils.h" 

#include "ilifuids.h"

#include <openmax/il/khronos/v1_x/OMX_Types.h>

const TUint32  KOMXALL = 0xFFFFFFFF;

EXPORT_C COmxILGenericILIF::COmxILGenericILIF()

	{ 

	}

EXPORT_C COmxILGenericILIF::~COmxILGenericILIF()

	{

	if (iBody)

		{

		delete iBody;

		}

	}

EXPORT_C void COmxILGenericILIF::CreateComponentL(const TDesC8& aComponentName, 

												  MILIfObserver& aComponentIfObserver)

	{

	iBody = CBody::NewL(*this, aComponentIfObserver, aComponentName);

	User::LeaveIfError(iBody->SetPortsL());

	}

EXPORT_C void COmxILGenericILIF::CreateComponentL(const TUid& /*aUid*/, 

												  MILIfObserver& /*ComponentIfObserver*/)

	{

	// OMX Versions do not use this method of creation

	User::Leave(KErrNotSupported);

	}

EXPORT_C void COmxILGenericILIF::ReleaseComponent()

	{

	delete iBody;

	iBody = NULL;

	delete this;

	}

EXPORT_C TInt COmxILGenericILIF::GetComponentInputPorts(RPointerArray<MILComponentPortIf>& aComponentPorts) const

	{

	return (iBody->GetComponentPorts(aComponentPorts, OMX_DirInput));

	}

EXPORT_C TInt COmxILGenericILIF::GetComponentOutputPorts(RPointerArray<MILComponentPortIf>& aComponentPorts) const

	{

	return (iBody->GetComponentPorts(aComponentPorts, OMX_DirOutput));	

	}

EXPORT_C TInt COmxILGenericILIF::SetConfig(const TILStruct& /*aConfig*/, 

										   const MILComponentPortIf* /*aComponentPort*/) 

	{

	// It should be implemented in the derived class

	return (KErrNotSupported);

	}	

EXPORT_C TInt COmxILGenericILIF::GetConfig(TILStruct& /*aConfig*/, 

										   const MILComponentPortIf* /*aComponentPort*/) const

	{

	// It should be implemented in the derived class

	return (KErrNotSupported);

	}

EXPORT_C TInt COmxILGenericILIF::Initialize()

	{

	return (iBody->OmxSendCommand(OMX_CommandStateSet, OMX_StateIdle, NULL));

	}

EXPORT_C TInt COmxILGenericILIF::Execute()

	{

	return (iBody->OmxSendCommand(OMX_CommandStateSet, OMX_StateExecuting, NULL));

	} 

EXPORT_C TInt COmxILGenericILIF::Pause()

	{

	return (iBody->OmxSendCommand(OMX_CommandStateSet, OMX_StatePause, NULL));

	}

EXPORT_C TInt COmxILGenericILIF::Stop()

	{

	return (iBody->OmxSendCommand(OMX_CommandStateSet, OMX_StateIdle, NULL));	

	}

EXPORT_C TInt COmxILGenericILIF::UnInitialize()

	{

	return (iBody->OmxSendCommand(OMX_CommandStateSet, OMX_StateLoaded, NULL));	

	}

EXPORT_C TInt COmxILGenericILIF::GetState(TILComponentState& aState) const

	{

	TInt error; 

	OMX_STATETYPE state;

	error = iBody->OmxGetState(&state);

	aState = ConvertOmxState(state);

	return error;

	}

EXPORT_C TInt COmxILGenericILIF::SendCommand(const TILCommand& aCommand)

	{

	OMX_COMMANDTYPE command = ConvertSymbianCommandType(aCommand.iCmd);

	return (iBody->OmxSendCommand(command, aCommand.iData1, aCommand.iExtraData));

	}

EXPORT_C TInt COmxILGenericILIF::FlushAllPorts()

	{

	return (iBody->OmxSendCommand(OMX_CommandFlush, KOMXALL, NULL));

	}

EXPORT_C TInt COmxILGenericILIF::ComponentRoleEnum(TPtr8& aComponentRole, 

												   TUint32 aIndex) const

	{

	return (iBody->OmxComponentRoleEnum(aComponentRole, aIndex));

	}

EXPORT_C TInt COmxILGenericILIF::GetComponentVersion(TILComponentVersion& aVersion) const

	{

	return (iBody->OmxGetComponentVersion(aVersion.iComponentName, 

										  (OMX_VERSIONTYPE*)&aVersion.iComponentVersion, 

										  (OMX_VERSIONTYPE*)&aVersion.iSpecVersion, 

										  (OMX_UUIDTYPE*)&aVersion.iComponentUniqueID));	

	}

EXPORT_C TInt COmxILGenericILIF::SetComponentIfRole(const TUid& aComponentRole)

	{

	return (iBody->SetIfToRole(aComponentRole));

	}

EXPORT_C TInt COmxILGenericILIF::SetComponentIfRole(const TDesC8& /*aComponentRole*/)

	{

	// Under A3F the roles are identified by Format Uid rather than role names.

	return (KErrNotSupported);

	}

EXPORT_C TInt COmxILGenericILIF::GetComponentIfRole(TUid& aComponentRole) const

	{

	return (iBody->GetIfRole(aComponentRole));

	}

EXPORT_C TInt COmxILGenericILIF::GetComponentIfRole(TDes8& /*aComponentRole*/) const

	{

	// Under A3F the roles are identified by Format Uid rather than role names.

	return (KErrNotSupported);

	}

EXPORT_C TInt COmxILGenericILIF::SetExtConfig(const TDesC8& /*aParameterName*/, 

											  const TILStruct& /*aConfig*/, 

											  const MILComponentPortIf* /*aComponentPort*/)

	{

	// It should be implemented in the derived class

	return (KErrNotSupported);

	}

EXPORT_C TInt COmxILGenericILIF::GetExtConfig(const TDesC8& /*aParameterName*/, 

											  TILStruct& /*aConfig*/, 

											  const MILComponentPortIf* /*aComponentPort*/) const

	{

	// It should be implemented in the derived class

	return (KErrNotSupported);

	}

EXPORT_C TAny* COmxILGenericILIF::CustomInterface(TUid aUid)

	{

	if (aUid == KUidILComponentIf)

		{

		MILComponentIf* componentIf = this;

		return componentIf;

		}

	else		

		{

		return NULL;

		}

	}

EXPORT_C TInt COmxILGenericILIF::FillBufferDone(CMMFBuffer* aBuffer, 

												TInt aPortIndex)

	{

	return (iBody->FillBufferDone(aBuffer, aPortIndex));

	}

EXPORT_C TInt COmxILGenericILIF::EmptyBufferDone(const CMMFBuffer* aBuffer, 

												 TInt aPortIndex)

	{

	return (iBody->EmptyBufferDone(aBuffer, aPortIndex));

	}

EXPORT_C TInt COmxILGenericILIF::EventHandler(OMX_EVENTTYPE aEvent, 

											  TUint32 aData1, 

											  TUint32 aData2, 

											  TAny* aExtraInfo)

	{

	return (iBody->EventHandler(aEvent, aData1, aData2, aExtraInfo));

	}

EXPORT_C TInt COmxILGenericILIF::OmxGetParameter(OMX_INDEXTYPE aParamIndex, 

												 TAny* aComponentParameterStructure) const

	{

	return (iBody->OmxGetParameter(aParamIndex, aComponentParameterStructure));

	}

EXPORT_C TInt COmxILGenericILIF::OmxSetParameter(OMX_INDEXTYPE aParamIndex, 

												 TAny* aComponentParameterStructure)

	{

	return (iBody->OmxSetParameter(aParamIndex, aComponentParameterStructure));

	}

EXPORT_C TInt COmxILGenericILIF::OmxGetConfig(OMX_INDEXTYPE aConfigIndex, 

											  TAny* aValue) const

	{

	return (iBody->OmxGetConfig(aConfigIndex, aValue));

	}

EXPORT_C TInt COmxILGenericILIF::OmxSetConfig(OMX_INDEXTYPE aConfigIndex, 

											  TAny* aValue) 

	{

	return (iBody->OmxSetConfig(aConfigIndex, aValue));

	}

EXPORT_C TInt COmxILGenericILIF::OmxGetExtensionIndex(const TDesC8& aParameterName, 

											 OMX_INDEXTYPE* aIndexType) const

	{

	return (iBody->OmxGetExtensionIndex(aParameterName, aIndexType));

	}

TInt COmxILGenericILIF::OmxSendCommand(OMX_COMMANDTYPE aCmd, 

									   TUint32 aParam1, 

									   TAny* aCmdData)

	{

	return (iBody->OmxSendCommand(aCmd, aParam1, aCmdData));

	}

TInt COmxILGenericILIF::OmxComponentTunnelRequest(TUint32 aPortInput, 

												  OMX_HANDLETYPE aOutput, 

												  TUint32 aPortOutput)

	{

	return (iBody->OmxComponentTunnelRequest(aPortInput, aOutput, aPortOutput));

	}

TInt COmxILGenericILIF::OmxComponentDisconnectTunnel(TUint32 aPortInput, 

												    OMX_HANDLETYPE aOutput, 

												    TUint32 aPortOutput)

	{

	return (iBody->OmxComponentDisconnectTunnel(aPortInput, aOutput, aPortOutput));

	}

TInt COmxILGenericILIF::OmxUseBuffer(CMMFBuffer* aBuffer, 

									 TUint32 aPortIndex)

	{

	return (iBody->OmxUseBuffer(aBuffer, aPortIndex));

	}

CMMFBuffer* COmxILGenericILIF::OmxAllocateBufferL(TUint32 aPortIndex, 

												  TUint32 aSizeBytes)

	{

	return (iBody->OmxAllocateBufferL(aPortIndex, aSizeBytes));

	}

TInt COmxILGenericILIF::OmxFreeBuffer(CMMFBuffer* aBuffer)

	{

	return (iBody->OmxFreeBuffer(aBuffer));

	}

TInt COmxILGenericILIF::OmxEmptyThisBuffer(const CMMFBuffer* aBuffer, 

										   MOmxILComponentIfObserver* aObserver)

	{

	return (iBody->OmxEmptyThisBuffer(aBuffer, aObserver));

	}

TInt COmxILGenericILIF::OmxFillThisBuffer(CMMFBuffer* aBuffer, 

										  MOmxILComponentIfObserver* aObserver)

	{

	return (iBody->OmxFillThisBuffer(aBuffer, aObserver));

	}

OMX_COMPONENTTYPE* COmxILGenericILIF::OmxHandle() const

	{

	return (iBody->Handle());	

	}