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

 // omxoutputport.cpp

 // 

 //

 #include <omxprocessingunit.h>

 #include <mdf/mdfpuconfig.h>

 #include "omxcomponentbody.h"

 #include "omxoutputportbody.h"

 COmxOutputPort::CBody* COmxOutputPort::CBody::NewL(TInt aIndex, COmxProcessingUnit* aComponent, COmxOutputPort* aParent)

 	{

 	return new (ELeave) CBody(aIndex, aComponent, aParent);	

 	}  

 COmxOutputPort::CBody::CBody(TInt aIndex, COmxProcessingUnit* aComponent, COmxOutputPort* aParent) :

 	iPortIndex(aIndex),	

 	iComponent(aComponent),

 	iParent(aParent)

 	{

 	}

 void COmxOutputPort::CBody::MopSetObserver(const MMdfOutputPortObserver& aOutputPortObserver) 

 	{

 	iObserver = const_cast<MMdfOutputPortObserver*>(&aOutputPortObserver);

 	}

 void COmxOutputPort::CBody::MipoWriteDataComplete(const MMdfInputPort* /*aInputPort*/,

 		CMMFBuffer* aBuffer, TInt /*aErrorCode*/)

 	{

 	// the parent class read must be called in case it has been overridden in a derived class

 	iParent->MopReadData(*aBuffer);

 	}

 void COmxOutputPort::CBody::MipoDisconnectTunnelComplete(const MMdfInputPort* /*aInputPort*/,

 		TInt /*aErrorCode*/)

 	{

 	}

 void COmxOutputPort::CBody::MipoRestartTunnelComplete(const MMdfInputPort* /*aInputPort*/,

 		TInt /*aErrorCode*/)

 	{	

 	}

 TInt COmxOutputPort::CBody::FillBufferDone(OMX_HANDLETYPE /*aComponent*/, CMMFBuffer* aBuffer)

 	{

 	__ASSERT_ALWAYS(iObserver, User::Panic(_L("OmxOutputPort"), EObserverNotSet));

 	if (iPortConnectedTo)

 		{

 		iPortConnectedTo->MipWriteData(*aBuffer);

 		}

 	else

 		{

 		if (iObserver)

 			{

 			iObserver->MopoReadDataComplete(iParent, aBuffer, KErrNone);				

 			}

 		}

 	return KErrNone;

 	}

 TInt COmxOutputPort::CBody::MopConfigure(const TPuConfig&  /*aConfig*/)

 	{

 	return KErrNotSupported;	

 	}

 TInt COmxOutputPort::CBody::MopGetConfig(TPuConfig& /*aConfig*/)

 	{

 	return KErrNotSupported;	

 	}		

 void COmxOutputPort::CBody::MopInitialize()	

  	{

  	if (iPortConnectedTo != NULL)

  		{

  		iPortConnectedTo->MipSetObserver(*iParent);

  		}

  	}

 CMMFBuffer* COmxOutputPort::CBody::MopCreateBuffer(TInt aBufferSize)

 	{

 	CMMFBuffer* buffer = NULL;

 	TInt err = KErrNone;

 	TRAP(err, buffer = Component()->OmxAllocateBufferL(iPortIndex, aBufferSize));	

 	return buffer;

 	}

 TInt COmxOutputPort::CBody::MopUseBuffer(CMMFBuffer& aBuffer)

 	{

 	if (iPortConnectedTo)

 		{

 		iPortConnectedTo->MipUseBuffer(aBuffer);

 		}

 	return Component()->OmxUseBuffer(&aBuffer, iPortIndex);	

 	}

 TInt COmxOutputPort::CBody::MopFreeBuffer(CMMFBuffer* aBuffer)

 	{

 	return Component()->OmxFreeBuffer(aBuffer);	

 	}

 TInt COmxOutputPort::CBody::MopTunnelRequest(const MMdfInputPort& aInputPortToBeConnectedTo,

 		TTunnelFlags& aTunnelFlags, TSupplierType& aSupplierType) 

 	{

 	if ((Component()->State()!=EProcessingUnitLoaded) && (!iStopped))

 		{

 		// invalid state

 		return EInvalidState;

 		}

 	if (iPortConnectedTo)

 		{

 		// the port is already connected, return an error

 		return EPortAlreadyTunnelled;

 		}

 	aTunnelFlags = EBufferReadOnly;

 	aSupplierType = EBufferSupplyOutput;

 	iPortConnectedTo = const_cast<MMdfInputPort*>(&aInputPortToBeConnectedTo);

 	return KErrNone;

 	}

 void COmxOutputPort::CBody::MopReadData(CMMFBuffer& aBuffer)

 	{

 	Component()->OmxFillThisBuffer(&aBuffer, this);	

 	}

 void COmxOutputPort::CBody::MopDisconnectTunnel()

 	{

 	if(iObserver) 

 		{

 		iObserver->MopoDisconnectTunnelComplete(iParent, KErrNone);		

 		}

 	}

 void COmxOutputPort::CBody::MopRestartTunnel()

 	{

 	}

 TBool COmxOutputPort::CBody::MopIsTunnelled() const

 	{

 	if (!iPortConnectedTo)

 		{

 		return EFalse;

 		}		

 	return ETrue;

 	}

 TInt COmxOutputPort::CBody::MopIndex() const

 	{

 	return iPortIndex;

 	}

 TUint32 COmxOutputPort::CBody::MopBufferSize() const

 	{

 	OMX_PARAM_PORTDEFINITIONTYPE portInfo;

 	portInfo.nPortIndex = 1;

 	Component()->OmxGetParameter(OMX_IndexParamPortDefinition, &portInfo);	

 	return portInfo.nBufferSize;

 	}

 TInt COmxOutputPort::CBody::MopCreateCustomInterface(TUid /*aUid*/)

 	{

 	return KErrNotSupported;

 	}

 TAny* COmxOutputPort::CBody::MopCustomInterface(TUid /*aUid*/)

 	{

 	return NULL;	

 	}

 MMdfOutputPortObserver* COmxOutputPort::CBody::Observer() const

 	{

 	return iObserver;

 	}

 COmxProcessingUnit* COmxOutputPort::CBody::Component() const

 	{

 	return iComponent;

 	}