// 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 "omxildummybaseilifbody.h"
#include "omxilcoreutils.h"
#include "omxilspecversion.h"
#include "milifobserver.h"
#include "tilstructtypes.h"


const TInt KMaxComponentNameLength = 128;


COmxILDummyBaseILIF::CBody::CBody(COmxILDummyBaseILIF& aParent,
								  MILIfObserver& aComponentIfObserver)
	:
	iParent(aParent),
	iIfObserver(aComponentIfObserver)
    {
    }

COmxILDummyBaseILIF::CBody::~CBody()
    {
    iInputPorts.ResetAndDestroy();
    iInputPorts.Close();
    iOutputPorts.ResetAndDestroy();
    iOutputPorts.Close();
    delete iBufferManager;    
    delete iCallbacks;    

	::OMX_FreeHandle(reinterpret_cast<OMX_HANDLETYPE>(iHandle));
    }

COmxILDummyBaseILIF::CBody* COmxILDummyBaseILIF::CBody::NewL(COmxILDummyBaseILIF& aParent,
													 	 MILIfObserver& aComponentIfObserver,
													 	 const TDesC8& aComponentName)
    {
	CBody* self = new (ELeave) CBody(aParent, aComponentIfObserver);
    CleanupStack::PushL(self);
	self->ConstructL(aComponentName);
    CleanupStack::Pop(self);
    return self;
    }
    
void COmxILDummyBaseILIF::CBody::ConstructL(const TDesC8& aComponentName)
    {
	iCallbacks = COmxCallbacks::NewL(iParent);
	
	RBuf8 buf;
	buf.CleanupClosePushL();
	buf.CreateL(aComponentName, KMaxComponentNameLength);
    TUint8* name = const_cast<TUint8*>(buf.PtrZ());

	OMX_ERRORTYPE errorType = ::OMX_GetHandle(reinterpret_cast<OMX_HANDLETYPE*>(&iHandle), 
								reinterpret_cast<OMX_STRING>(name), 
								iCallbacks, 
							    *iCallbacks);
	CleanupStack::PopAndDestroy(&buf);

    User::LeaveIfError(ConvertOmxErrorType(errorType));

    iBufferManager = new (ELeave) COmxBufferManager(iHandle);
    }

OMX_COMPONENTTYPE* COmxILDummyBaseILIF::CBody::Handle() const
    {
    return iHandle;    
    }
    
TInt COmxILDummyBaseILIF::CBody::OmxGetComponentVersion(TPtr8 aComponentName, 
                                                        OMX_VERSIONTYPE* aComponentVersion, 
                                                        OMX_VERSIONTYPE* aSpecVersion, 
                                                        OMX_UUIDTYPE* aComponentUUID)
    {
	ASSERT(aComponentVersion);
	ASSERT(aSpecVersion);
	ASSERT(aComponentUUID);
    TUint8* cname = const_cast<TUint8*>(aComponentName.PtrZ());
    OMX_ERRORTYPE error = iHandle->GetComponentVersion(reinterpret_cast<OMX_HANDLETYPE>(iHandle), 
						  reinterpret_cast<OMX_STRING>(cname), aComponentVersion, aSpecVersion, aComponentUUID);

	TLex8 lex(cname);
	TInt length;
	for( length = 0; !lex.Eos(); ++length )
		{
		lex.Inc();
		}
	aComponentName.SetLength(length);
    return ConvertOmxErrorType(error);
    }
    
TInt COmxILDummyBaseILIF::CBody::OmxSendCommand(OMX_COMMANDTYPE aCmd, 
												TUint32 aParam, 
												TAny* aCmdData)
    {
	OMX_ERRORTYPE error = iHandle->SendCommand(reinterpret_cast<OMX_HANDLETYPE>(iHandle), aCmd, aParam, aCmdData);
    return ConvertOmxErrorType(error);
    }

TInt COmxILDummyBaseILIF::CBody::OmxGetParameter(OMX_INDEXTYPE aParamIndex, 
												 TAny* aValue)
    {
	ASSERT(aValue);
	OMX_ERRORTYPE error = iHandle->GetParameter(reinterpret_cast<OMX_HANDLETYPE>(iHandle), aParamIndex, aValue);
    return ConvertOmxErrorType(error);
    }
    
TInt COmxILDummyBaseILIF::CBody::OmxSetParameter(OMX_INDEXTYPE aIndex, 
												 TAny* aValue)
    {
	ASSERT(aValue);
	OMX_ERRORTYPE error = iHandle->SetParameter(reinterpret_cast<OMX_HANDLETYPE>(iHandle), aIndex, aValue);
    return ConvertOmxErrorType(error);
    }

TInt COmxILDummyBaseILIF::CBody::OmxGetConfig(OMX_INDEXTYPE aIndex, 
											  TAny* aValue)
    {
	ASSERT(aValue);
	OMX_ERRORTYPE error = iHandle->GetConfig(reinterpret_cast<OMX_HANDLETYPE>(iHandle), aIndex, aValue);
    return ConvertOmxErrorType(error);
    }
    
TInt COmxILDummyBaseILIF::CBody::OmxSetConfig(OMX_INDEXTYPE aIndex, 
											  TAny* aValue)
    {
	ASSERT(aValue);
	OMX_ERRORTYPE error = iHandle->SetConfig(reinterpret_cast<OMX_HANDLETYPE>(iHandle), aIndex, aValue);
    return ConvertOmxErrorType(error);
    }
    
TInt COmxILDummyBaseILIF::CBody::OmxGetExtensionIndex(const TDesC8& aParameterName, 
													  OMX_INDEXTYPE* aIndexType)
{
    HBufC8* buf = HBufC8::New(aParameterName.Length()+1);
    if (buf == NULL)
        {
        return KErrNoMemory;
        }
    else
        {
		*buf = aParameterName;
		TUint8* cstring = const_cast<TUint8*>(buf->Des().PtrZ());
		OMX_ERRORTYPE error = iHandle->GetExtensionIndex(reinterpret_cast<OMX_HANDLETYPE>(iHandle), reinterpret_cast<char*>(cstring), aIndexType);
		delete buf;
		return ConvertOmxErrorType(error);
        }
    }

TInt COmxILDummyBaseILIF::CBody::OmxGetState(OMX_STATETYPE*  aState)
    {
	OMX_ERRORTYPE error = iHandle->GetState(reinterpret_cast<OMX_HANDLETYPE>(iHandle), aState);
    return ConvertOmxErrorType(error);
    }
    
TInt COmxILDummyBaseILIF::CBody::OmxComponentTunnelRequest(TUint32 aPortInput, 
														   OMX_HANDLETYPE aOutput, 
														   TUint32 aPortOutput)
    {
	OMX_ERRORTYPE error = ::OMX_SetupTunnel(aOutput, aPortOutput, reinterpret_cast<OMX_HANDLETYPE>(iHandle), aPortInput);
    return ConvertOmxErrorType(error);
    }

TInt COmxILDummyBaseILIF::CBody::OmxComponentDisconnectTunnel(TUint32 aPortInput, 
														 	  OMX_HANDLETYPE aOutput, 
														 	  TUint32 aPortOutput)
	{
	OMX_ERRORTYPE error = ::OMX_SetupTunnel(aOutput, aPortOutput, 0, 0);
	if (error == OMX_ErrorNone)
		{
		error = ::OMX_SetupTunnel(0, 0, reinterpret_cast<OMX_HANDLETYPE>(iHandle), aPortInput);
		}
	return ConvertOmxErrorType(error);
	}
    
TInt COmxILDummyBaseILIF::CBody::OmxUseBuffer(CMMFBuffer* aBuffer, 
											  TUint32 aPortIndex)
    {
	ASSERT(aBuffer);
    return (iBufferManager->UseBuffer(*aBuffer, aPortIndex));    
    }

CMMFBuffer* COmxILDummyBaseILIF::CBody::OmxAllocateBufferL(TUint32 aPortIndex, 
														   TUint32 aSizeBytes)
    {
    return (iBufferManager->AllocateBufferL(aPortIndex, aSizeBytes));
    }

TInt COmxILDummyBaseILIF::CBody::OmxFreeBuffer(CMMFBuffer* aBuffer)
    {
	ASSERT(aBuffer);
    return (iBufferManager->FreeBuffer(aBuffer));
    }

TInt COmxILDummyBaseILIF::CBody::OmxEmptyThisBuffer(const CMMFBuffer* aBuffer, 
													MOmxILComponentIfObserver* aObserver)
    {
	ASSERT(aBuffer);
    return (iBufferManager->EmptyThisBuffer(aBuffer, aObserver));
    }

TInt COmxILDummyBaseILIF::CBody::OmxFillThisBuffer(CMMFBuffer* aBuffer, 
												   MOmxILComponentIfObserver* aObserver)
    {
	ASSERT(aBuffer);
    return (iBufferManager->FillThisBuffer(aBuffer, aObserver));
    }

TInt COmxILDummyBaseILIF::CBody::OmxComponentRoleEnum(TPtr8& aComponentRole, 
													  TUint32 aIndex)
    {
    TUint8* role = const_cast<TUint8*> (aComponentRole.PtrZ());
	OMX_ERRORTYPE error = iHandle->ComponentRoleEnum(reinterpret_cast<OMX_HANDLETYPE>(iHandle), reinterpret_cast<unsigned char*>(role), aIndex);

	TLex8 lex(role);
	TInt length;
	for( length = 0; !lex.Eos(); ++length )
		{
		lex.Inc();
		}
	aComponentRole.SetLength(length);

    return ConvertOmxErrorType(error);
    }

TInt COmxILDummyBaseILIF::CBody::SetIfToRole(const TUid& aComponentRole)
    {
    iFormat = aComponentRole;
    return KErrNone;
    }

TInt COmxILDummyBaseILIF::CBody::GetIfRole(TUid& aComponentRole) const
    {
    aComponentRole = iFormat;
    return KErrNone;    
    }

TInt COmxILDummyBaseILIF::CBody::SetPortsL()
    {
    OMX_PORT_PARAM_TYPE param;
    param.nVersion = KOMXILSpecVersion;
    param.nSize = sizeof(OMX_PORT_PARAM_TYPE);
    TInt err = OmxGetParameter(OMX_IndexParamAudioInit, &param);
    
    if (err == KErrNone)
        {
        for (TInt i=0; i < param.nPorts && err == KErrNone; i++ )
            {
            OMX_PARAM_PORTDEFINITIONTYPE portInfo;
            portInfo.nPortIndex = i;
			portInfo.nVersion = KOMXILSpecVersion;
			portInfo.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
            err = OmxGetParameter(OMX_IndexParamPortDefinition, &portInfo);    
			if (err == KErrNone)
				{
            if (portInfo.eDir == OMX_DirInput)
                {
                COmxILDummyBasePortILIF* inputPort = COmxILDummyBasePortILIF::NewL(iParent, EDirInput, portInfo.nPortIndex);
                err = iInputPorts.Append(inputPort);
                }
            else
                {
                COmxILDummyBasePortILIF* outputPort = COmxILDummyBasePortILIF::NewL(iParent, EDirOutput, portInfo.nPortIndex);
                err = iOutputPorts.Append(outputPort);                
					}
				}
			}
		}
    return err;
    }

TInt COmxILDummyBaseILIF::CBody::GetComponentPorts(RPointerArray<MILComponentPortIf>& aComponentPorts, 
												   OMX_DIRTYPE aDirection)
    {
    TInt err = KErrNone;
    if     (aDirection == OMX_DirInput)
        {
		const TInt counter = iInputPorts.Count();
		for (TInt i=0; i < counter && err == KErrNone; i++ )
            {
            err = aComponentPorts.Append(iInputPorts[i]);
            }
        }
    else if (aDirection == OMX_DirOutput)
        {
		const TInt counter = iOutputPorts.Count();
		for (TInt i=0; i < counter && err == KErrNone; i++ )
            {
            err = aComponentPorts.Append(iOutputPorts[i]);
            }            
        }
    else 
        {
        err = KErrNotSupported;
        }
    return err;
    }

TInt COmxILDummyBaseILIF::CBody::FillBufferDone(CMMFBuffer* aBuffer, 
												TInt aPortIndex)
    {
	ASSERT(aBuffer);
    // Loop through all output ports to search for the interface associated to this port index
	const TInt counter = iOutputPorts.Count();
	for (TInt i=0; i < counter; i++ )
        {
        if (iOutputPorts[i]->PortIndex() == aPortIndex)
            {
			return (iIfObserver.BufferDelivered(iOutputPorts[i], aBuffer));
            }
        }

    return KErrNotFound;
    }

TInt COmxILDummyBaseILIF::CBody::EmptyBufferDone(const CMMFBuffer* aBuffer, 
												 TInt aPortIndex)
    {
	ASSERT(aBuffer);
    // Loop through all input ports to search for the interface associated to this port index
	const TInt counter = iInputPorts.Count();
	for (TInt i=0; i < counter; i++ )
        {
        if (iInputPorts[i]->PortIndex() == aPortIndex)
            {
			return (iIfObserver.BufferDelivered(iInputPorts[i], aBuffer));
            }
        }

    return KErrNotFound;
    }

TInt COmxILDummyBaseILIF::CBody::EventHandler(OMX_EVENTTYPE aEvent, 
											  TUint32 aData1, 
											  TUint32 aData2, 
											  TAny* /*aExtraInfo*/)
    {
    TInt err = KErrNone;
    TILEvent thisEvent;

	switch (aEvent)
		{
		case OMX_EventCmdComplete:
			{
			thisEvent.iEvent = EEventCmdComplete;
			if (aData1 == OMX_CommandStateSet)
				{
				thisEvent.iData1 = ECommandStateSet;				
				OMX_STATETYPE state = static_cast<OMX_STATETYPE>(aData2);	
				thisEvent.iData2 = ConvertOmxState(state);
				err = iIfObserver.MsgFromILComponent(&iParent, thisEvent); 
				break;	
				}
			else if (aData1 == OMX_CommandFlush)
				{
				thisEvent.iData1 = ECommandFlush;				
				thisEvent.iData2 = aData2; // Port index
				err = iIfObserver.MsgFromILComponent(&iParent, thisEvent); 
				}
			else if (aData1 == OMX_CommandPortDisable)
				{
				thisEvent.iData1 = ECommandPortDisable;				
				thisEvent.iData2 = aData2; // Port index
				err = iIfObserver.MsgFromILComponent(&iParent, thisEvent); 
				}
			else if (aData1 == OMX_CommandPortEnable)
				{
				thisEvent.iData1 = ECommandPortEnable;				
				thisEvent.iData2 = aData2; // Port index
				err = iIfObserver.MsgFromILComponent(&iParent, thisEvent); 
				}
			else 
				{
				err = KErrNotSupported; 
				}
			
			break;
			}
		case OMX_EventBufferFlag:
			{
			// Propagate the EOF up to client as KErrUnderflow
			thisEvent.iEvent = EEventBufferFlag;
			thisEvent.iData1 = aData1;				
			thisEvent.iData2 = static_cast<TUint32>(KErrUnderflow);
			err = iIfObserver.MsgFromILComponent(&iParent, thisEvent); 
			break;
			}
		case OMX_EventError:
			{
			// Propagate the error up to client
			thisEvent.iEvent = EEventError;
			OMX_ERRORTYPE errorx = static_cast<OMX_ERRORTYPE>(aData1);
			thisEvent.iData1 = ConvertOmxErrorType(errorx);				
			err = iIfObserver.MsgFromILComponent(&iParent, thisEvent); 
			break;
			}
		default:
			{
			err = KErrNotSupported;
			}
		}
	return err;
	}