// 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;
	}