--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omxil/mmilapi/refomxil/src/omxilgenericilif/omxilgenericilifbody.cpp Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,430 @@
+// 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 "omxilgenericilifbody.h"
+#include "omxilcoreutils.h"
+#include "omxilspecversion.h"
+#include "milifobserver.h"
+#include "tilstructtypes.h"
+
+
+const TInt KMaxComponentNameLength = 128;
+
+
+COmxILGenericILIF::CBody::CBody(COmxILGenericILIF& aParent,
+ MILIfObserver& aComponentIfObserver)
+ :
+ iParent(aParent),
+ iIfObserver(aComponentIfObserver)
+
+ {
+ }
+
+COmxILGenericILIF::CBody::~CBody()
+ {
+ iInputPorts.ResetAndDestroy();
+ iInputPorts.Close();
+ iOutputPorts.ResetAndDestroy();
+ iOutputPorts.Close();
+ delete iBufferManager;
+ delete iCallbacks;
+
+ ::OMX_FreeHandle(reinterpret_cast<OMX_HANDLETYPE>(iHandle));
+ }
+
+COmxILGenericILIF::CBody* COmxILGenericILIF::CBody::NewL(COmxILGenericILIF& 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 COmxILGenericILIF::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* COmxILGenericILIF::CBody::Handle() const
+ {
+ return iHandle;
+ }
+
+TInt COmxILGenericILIF::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 COmxILGenericILIF::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 COmxILGenericILIF::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 COmxILGenericILIF::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 COmxILGenericILIF::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 COmxILGenericILIF::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 COmxILGenericILIF::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 COmxILGenericILIF::CBody::OmxGetState(OMX_STATETYPE* aState)
+ {
+
+ OMX_ERRORTYPE error = iHandle->GetState(reinterpret_cast<OMX_HANDLETYPE>(iHandle), aState);
+ return ConvertOmxErrorType(error);
+ }
+
+TInt COmxILGenericILIF::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 COmxILGenericILIF::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 COmxILGenericILIF::CBody::OmxUseBuffer(CMMFBuffer* aBuffer,
+ TUint32 aPortIndex)
+ {
+ ASSERT(aBuffer);
+
+ return (iBufferManager->UseBuffer(*aBuffer, aPortIndex));
+ }
+
+CMMFBuffer* COmxILGenericILIF::CBody::OmxAllocateBufferL(TUint32 aPortIndex,
+ TUint32 aSizeBytes)
+ {
+ return (iBufferManager->AllocateBufferL(aPortIndex, aSizeBytes));
+ }
+
+TInt COmxILGenericILIF::CBody::OmxFreeBuffer(CMMFBuffer* aBuffer)
+ {
+ ASSERT(aBuffer);
+
+ return (iBufferManager->FreeBuffer(aBuffer));
+ }
+
+TInt COmxILGenericILIF::CBody::OmxEmptyThisBuffer(const CMMFBuffer* aBuffer,
+ MOmxILComponentIfObserver* aObserver)
+ {
+ ASSERT(aBuffer);
+
+ return (iBufferManager->EmptyThisBuffer(aBuffer, aObserver));
+ }
+
+TInt COmxILGenericILIF::CBody::OmxFillThisBuffer(CMMFBuffer* aBuffer,
+ MOmxILComponentIfObserver* aObserver)
+ {
+ ASSERT(aBuffer);
+
+ return (iBufferManager->FillThisBuffer(aBuffer, aObserver));
+ }
+
+TInt COmxILGenericILIF::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<OMX_U8*>(role), aIndex);
+
+ TLex8 lex(role);
+ TInt length;
+ for( length = 0; !lex.Eos(); ++length )
+ {
+ lex.Inc();
+ }
+ aComponentRole.SetLength(length);
+
+ return ConvertOmxErrorType(error);
+ }
+
+TInt COmxILGenericILIF::CBody::SetIfToRole(const TUid& aComponentRole)
+ {
+ iFormat = aComponentRole;
+ return KErrNone;
+ }
+
+TInt COmxILGenericILIF::CBody::GetIfRole(TUid& aComponentRole) const
+ {
+ aComponentRole = iFormat;
+ return KErrNone;
+ }
+
+TInt COmxILGenericILIF::CBody::SetPortsL()
+ {
+ OMX_PORT_PARAM_TYPE param;
+ param.nVersion = KOMXILSpecVersion;
+ param.nSize = sizeof(OMX_PORT_PARAM_TYPE);
+ TInt err = OmxGetParameter(OMX_IndexParamAudioInit, ¶m);
+
+ 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)
+ {
+ COmxILGenericPortILIF* inputPort = COmxILGenericPortILIF::NewL(iParent, EDirInput, portInfo.nPortIndex);
+ err = iInputPorts.Append(inputPort);
+ }
+ else
+ {
+ COmxILGenericPortILIF* outputPort = COmxILGenericPortILIF::NewL(iParent, EDirOutput, portInfo.nPortIndex);
+ err = iOutputPorts.Append(outputPort);
+ }
+ }
+ }
+ }
+ return err;
+ }
+
+TInt COmxILGenericILIF::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 COmxILGenericILIF::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 COmxILGenericILIF::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 COmxILGenericILIF::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;
+ }