// Copyright (c) 2005-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 <omxprocessingunit.h>
#include <omxinputport.h>
#include <mdf/mdfpuconfig.h>
#include "omxcomponentbody.h"
#include "omxinputportbody.h"

_LIT(KOmxInputPort, "OmxInputPort");

/**
Constructor.
*/
EXPORT_C COmxInputPort::COmxInputPort()
	{
	}

/**
Destructor.
*/
EXPORT_C COmxInputPort::~COmxInputPort()
	{
	delete iBody;
	}
	
/**
Class constructor.
*/
EXPORT_C void COmxInputPort::ConstructL(TInt aIndex, COmxProcessingUnit* aComponent)
	{
	__ASSERT_ALWAYS(!iBody, User::Panic(KOmxInputPort, EBodyNotCreated));
	iBody = CBody::NewL(aIndex, aComponent, this);
	}

	
/**
Synchronous function used to configure the OpenMAX Input Port.
@param  aConfiguration
		Holds the configuration parameters for the OpenMAX Input Port.
@return An error code indicating if the function call was successful. KErrNone on success, otherwise
	    nother of the system-wide error codes.
*/
EXPORT_C TInt COmxInputPort::MipConfigure(const TPuConfig& aConfig)
	{
	__ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated));
	return iBody->MipConfigure(aConfig);	
	}	
	

/**
Synchronous method which gets a configuration structure for the OpenMAX Input Port
@param  aConfig
		The reference to the structure that is to contain the configuration information.
@return An error code indicating if the function call was successful. KErrNone on success, otherwise
	    another of the system-wide error codes.	
*/
EXPORT_C TInt COmxInputPort::MipGetConfig(TPuConfig& aConfig)
	{
	__ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated));
	return iBody->MipGetConfig(aConfig);	
	}	


/**
Synchronous function used to initialise the OpenMAX Input Port.
*/
EXPORT_C void COmxInputPort::MipInitialize()
	{	
	__ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated));
	iBody->MipInitialize();
	}


/**
Synchronous function used to instruct the OpenMAX Input Port to create a buffer. 
@param  aBufferSize
		The size of the buffer to be created.
@return A pointer to the new created buffer.
*/
EXPORT_C CMMFBuffer* COmxInputPort::MipCreateBuffer(TInt aBufferSize)
	{
	__ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated));
	return iBody->MipCreateBuffer(aBufferSize);
	}


/**
Synchronous function used to instruct the OpenMAX Input Port to use the buffer 
passed in the function's argument. 
@param  aBuffer
		The buffer to be used by the Input Port.
@return An error code indicating if the function call was successful. KErrNone on success, otherwise
	    another of the system-wide error codes.
*/
EXPORT_C TInt COmxInputPort::MipUseBuffer(CMMFBuffer& aBuffer)
	{
	__ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated));
	return iBody->MipUseBuffer(aBuffer);		
	}


/**
Synchronous function used to instruct the OpenMAX Input Port to free the buffer given
passed in the function's argument. 
@param  aBuffer
		The buffer to be freed
@return An error code indicating if the function call was successful. KErrNone on success, otherwise
	    another of the system-wide error codes.
*/	
EXPORT_C TInt COmxInputPort::MipFreeBuffer(CMMFBuffer* aBuffer)
	{
	__ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated));
	return iBody->MipFreeBuffer(aBuffer);		
	}


/**
Synchronous function used to request the set up of a tunnel between this OpenMAX Input Port
and an OpenMAX Output Port.
@param  aOutputPortToBeConnectedTo
		Reference to the Output Port to be connected to.
@param  aTunnelFlags
		Control flags for tunneling
@param  aSupplierType
		Specifies the supplier of the buffers for the tunnel.
@return An error code indicating if the function call was successful. KErrNone on success, otherwise
	    another of the system-wide error codes.
*/
EXPORT_C TInt COmxInputPort::MipTunnelRequest(const MMdfOutputPort& aOutputPortToBeConnectedTo,
		TTunnelFlags& aTunnelFlags, TSupplierType& aSupplierType) 
	{
	__ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated));
	return iBody->MipTunnelRequest(aOutputPortToBeConnectedTo, aTunnelFlags, aSupplierType);
	}
	

/**
Asynchronous function used to write data to the OpenMAX Input Port.
@param  aBuffer
		Reference to the buffer containing data.
*/		 
EXPORT_C void COmxInputPort::MipWriteData(CMMFBuffer& aInputBuffer)
	{
	__ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated));
	iBody->MipWriteData(aInputBuffer);	
	}


/**
Asynchronous function used to disconnect a tunnelled port, and thus stop the data processing.
*/
EXPORT_C void COmxInputPort::MipDisconnectTunnel()
	{
	__ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated));
	iBody->MipDisconnectTunnel();
	}

/**
Asynchronous function used to restart the data processing of a tunnelled port.
*/		 
EXPORT_C void COmxInputPort::MipRestartTunnel()
	{
	__ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated));
	iBody->MipRestartTunnel();
	}		

	
/**
Synchronous function used to find out if an OpenMAX Input Port is tunnelled or not.
@return ETrue if the Input Port is tunnelled, EFalse otherwise.
*/		
EXPORT_C TBool COmxInputPort::MipIsTunnelled() const
	{
	__ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated));
	return iBody->MipIsTunnelled();
	}


/**
Synchronous function used to get the OpenMAX Input Port index
@return The OpenMAX Input Port index.
*/
EXPORT_C TInt COmxInputPort::MipIndex() const
	{
	__ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated));
	return iBody->MipIndex();
	}
	
	 
/**
Synchronous function used to get the size of the buffer(s) used by the OpenMAX Input Port.
@param The OpenMAX Input Port's buffer size.
*/		 
EXPORT_C TUint32 COmxInputPort::MipBufferSize() const
	{
	return iBody->MipBufferSize();
	}


/**
Synchronous function used to set the observer for the OpenMAX Input Port. 
@param  aOutputPortObserver
		The observer of the OpenMAX Input Port.
*/
EXPORT_C void COmxInputPort::MipSetObserver(const MMdfInputPortObserver& aOutputPortObserver)
	{
	iBody->MipSetObserver(aOutputPortObserver);
	}

/**
Request extension feature. This is intended to provide additional features. 
@param  aUid
	    Used to indicate which interface is required. 
@return Standard error code. KErrNotSupported is used to indicate that the particular
	    plugin is not used.
*/
EXPORT_C TInt COmxInputPort::MipCreateCustomInterface(TUid aUid)
	{
	return iBody->MipCreateCustomInterface(aUid);	
	}
		 	 
/**
Return previously created extension.
This returns a custom interface. This should only be used if CreateCustomInterface() has already
been called for the same UID value. This means that any construction for that interface
has already been called, and thus this call cannot fail.
@param aUid
	   Used to indicate which interface is required. 
@return The requested interface, or NULL if not known.
@see MipCreateCustomInterface()
*/
EXPORT_C TAny* COmxInputPort::MipCustomInterface(TUid aUid)
	{
	__ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated));
	return MipCustomInterface(aUid);
	}
	
/**
Synchronous function used to return the observer for the OpenMAx Input Port.
@return Pointer to this class obsever
*/	
EXPORT_C MMdfInputPortObserver* COmxInputPort::Observer() const
	{
	__ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated));
	return iBody->Observer();
	}

/**
Synchronous function used to return the OpenMAX Processing Unit this Input Port
belongs to. 
@return Pointer to the OpenMAX Processing Unit this Input Port belongs to. 
*/	
EXPORT_C COmxProcessingUnit* COmxInputPort::Component() const
	{
	__ASSERT_ALWAYS(iBody, User::Panic(KOmxInputPort, EBodyNotCreated));
	return iBody->Component();
	}