diff -r 000000000000 -r 40261b775718 omxil/omxilcomponentcommon/src/common/omxilcomponent.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/omxil/omxilcomponentcommon/src/common/omxilcomponent.cpp Tue Feb 02 01:56:55 2010 +0200 @@ -0,0 +1,395 @@ +// 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: +// + +/** + @file + @internalComponent +*/ + +#include "log.h" +#include "omxilcomponent.h" +#include "omxilfsm.h" +#include "omxilcallbackmanager.h" +#include "omxilconfigmanager.h" + + +EXPORT_C +COmxILComponent::COmxILComponent() + { + DEBUG_PRINTF(_L8("COmxILComponent::COmxILComponent")); + + } + + +EXPORT_C +COmxILComponent::~COmxILComponent() + { + DEBUG_PRINTF2(_L8("COmxILComponent::~COmxILComponent : Handle[%X]"), ipHandle); + iComponentName.Close(); + } + + +EXPORT_C void +COmxILComponent::InitComponentL() + { + DEBUG_PRINTF2(_L8("COmxILComponent::InitComponent : Handle[%X]"), ipHandle); + + __ASSERT_ALWAYS(ipHandle && ipFsm && ipConfigManager, User::Invariant()); + + char componentNamebuffer[OMX_MAX_STRINGNAME_SIZE]; + OMX_VERSIONTYPE componentVersion; + OMX_VERSIONTYPE specVersion; + OMX_UUIDTYPE componentUid; + + ipConfigManager->GetComponentVersion(componentNamebuffer, + &componentVersion, + &specVersion, + &componentUid); + TBuf8<128> componentNameBuf8; + componentNameBuf8 = const_cast(reinterpret_cast(componentNamebuffer)); + iComponentName.CreateL(componentNameBuf8, componentNameBuf8.Length() + 1); + iComponentName.PtrZ(); + DEBUG_PRINTF2(_L8("COmxILComponent::InitComponent : [%S]"), &iComponentName); + + // Fill in the component handle + ipHandle->nVersion = componentVersion; + // The FSM will take care of all the API calls + ipHandle->pComponentPrivate = ipFsm; + ipHandle->GetComponentVersion = COmxILComponent::GetComponentVersion; + ipHandle->SendCommand = COmxILComponent::SendCommand; + ipHandle->GetParameter = COmxILComponent::GetParameter; + ipHandle->SetParameter = COmxILComponent::SetParameter; + ipHandle->GetConfig = COmxILComponent::GetConfig; + ipHandle->SetConfig = COmxILComponent::SetConfig; + ipHandle->GetExtensionIndex = COmxILComponent::GetExtensionIndex; + ipHandle->GetState = COmxILComponent::GetState; + ipHandle->ComponentTunnelRequest = COmxILComponent::ComponentTunnelRequest; + ipHandle->UseBuffer = COmxILComponent::UseBuffer; + ipHandle->AllocateBuffer = COmxILComponent::AllocateBuffer; + ipHandle->FreeBuffer = COmxILComponent::FreeBuffer; + ipHandle->EmptyThisBuffer = COmxILComponent::EmptyThisBuffer; + ipHandle->FillThisBuffer = COmxILComponent::FillThisBuffer; + ipHandle->SetCallbacks = COmxILComponent::SetCallbacks; + ipHandle->ComponentDeInit = COmxILComponent::ComponentDeInit; + ipHandle->UseEGLImage = COmxILComponent::UseEGLImage; + ipHandle->ComponentRoleEnum = COmxILComponent::ComponentRoleEnum; + + OMX_ERRORTYPE omxRetValue = + ipCallbackManager->RegisterComponentHandle(ipHandle); + if (OMX_ErrorNone != omxRetValue) + { + if (OMX_ErrorInsufficientResources == omxRetValue) + { + User::Leave(KErrNoMemory); + } + User::Leave(KErrGeneral); + } + + // Let's init the FSM... + ipFsm->InitFsm(); + + } + +OMX_ERRORTYPE +COmxILComponent::GetComponentVersion( + OMX_HANDLETYPE aComponent, + OMX_STRING aComponentName, + OMX_VERSIONTYPE* apComponentVersion, + OMX_VERSIONTYPE* apSpecVersion, + OMX_UUIDTYPE* apComponentUUID) + { + DEBUG_PRINTF2(_L8("COmxILComponent::GetComponentVersion : Handle[%X]"), aComponent); + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + GetComponentVersion(aComponentName, apComponentVersion, + apSpecVersion, apComponentUUID); + return omxError; + } + +OMX_ERRORTYPE +COmxILComponent::SendCommand( + OMX_HANDLETYPE aComponent, + OMX_COMMANDTYPE aCmd, + OMX_U32 aParam1, + OMX_PTR aCmdData) + { + DEBUG_PRINTF2(_L8("COmxILComponent::SendCommand : Handle[%X]"), aComponent); + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + SendCommand(aCmd ,aParam1, aCmdData); + + return omxError; + } + +OMX_ERRORTYPE +COmxILComponent::GetParameter( + OMX_HANDLETYPE aComponent, + OMX_INDEXTYPE aParamIndex, + OMX_PTR aComponentParameterStructure) + { + DEBUG_PRINTF3(_L8("COmxILComponent::GetParameter : Handle[%X]; ParamIndex[0x%X]"), aComponent, aParamIndex); + + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + GetParameter(aParamIndex, aComponentParameterStructure); + + return omxError; + } + +OMX_ERRORTYPE +COmxILComponent::SetParameter( + OMX_HANDLETYPE aComponent, + OMX_INDEXTYPE aIndex, + OMX_PTR aComponentParameterStructure) + { + DEBUG_PRINTF3(_L8("COmxILComponent::SetParameter : Handle[%X]; ParamIndex[0x%X]"), aComponent, aIndex); + + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + SetParameter(aIndex, + const_cast(aComponentParameterStructure)); + + return omxError; + } + +OMX_ERRORTYPE +COmxILComponent::GetConfig( + OMX_HANDLETYPE aComponent, + OMX_INDEXTYPE aIndex, + OMX_PTR aComponentParameterStructure) + { + DEBUG_PRINTF3(_L8("COmxILComponent::GetConfig : Handle[%X]; ConfigIndex[0x%X]"), aComponent, aIndex); + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + GetConfig(aIndex, aComponentParameterStructure); + return omxError; + } + +OMX_ERRORTYPE +COmxILComponent::SetConfig( + OMX_HANDLETYPE aComponent, + OMX_INDEXTYPE aIndex, + OMX_PTR aComponentConfigStructure) + { + DEBUG_PRINTF3(_L8("COmxILComponent::SetConfig : Handle[%X]; ConfigIndex[0x%X]"), aComponent, aIndex); + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + SetConfig(aIndex, const_cast(aComponentConfigStructure)); + return omxError; + } + +OMX_ERRORTYPE +COmxILComponent::GetExtensionIndex( + OMX_HANDLETYPE aComponent, + OMX_STRING aParameterName, + OMX_INDEXTYPE* aIndexType) + { + DEBUG_PRINTF2(_L8("COmxILComponent::GetExtensionIndex : Handle[%X]"), aComponent); + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + GetExtensionIndex(aParameterName, aIndexType); + return omxError; + } + +OMX_ERRORTYPE +COmxILComponent::GetState( + OMX_HANDLETYPE aComponent, + OMX_STATETYPE* aState) + { + DEBUG_PRINTF2(_L8("COmxILComponent::GetState : Handle[%X]"), aComponent); + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + GetState(aState); + return omxError; + } + +OMX_ERRORTYPE +COmxILComponent::ComponentTunnelRequest( + OMX_HANDLETYPE aComponent, + OMX_U32 aPort, + OMX_HANDLETYPE aTunneledComp, + OMX_U32 aTunneledPort, + OMX_TUNNELSETUPTYPE* aTunnelSetup) + { + DEBUG_PRINTF2(_L8("COmxILComponent::ComponentTunnelRequest : Handle[%X]"), aComponent); + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + ComponentTunnelRequest(aPort, aTunneledComp, + aTunneledPort, aTunnelSetup); + return omxError; + } + +OMX_ERRORTYPE +COmxILComponent::UseBuffer( + OMX_HANDLETYPE aComponent, + OMX_BUFFERHEADERTYPE** appBufferHdr, + OMX_U32 aPortIndex, + OMX_PTR apAppPrivate, + OMX_U32 aSizeBytes, + OMX_U8* aBuffer) + { + DEBUG_PRINTF2(_L8("COmxILComponent::UseBuffer : Handle[%X]"), aComponent); + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + UseBuffer(appBufferHdr, aPortIndex, apAppPrivate, aSizeBytes, aBuffer); + return omxError; + } + +OMX_ERRORTYPE +COmxILComponent::AllocateBuffer( + OMX_HANDLETYPE aComponent, + OMX_BUFFERHEADERTYPE** apBuffer, + OMX_U32 aPortIndex, + OMX_PTR aAppData, + OMX_U32 aSizeBytes) + { + DEBUG_PRINTF2(_L8("COmxILComponent::AllocateBuffer : Handle[%X]"), aComponent); + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + AllocateBuffer(apBuffer, aPortIndex, aAppData, aSizeBytes); + return omxError; + } + +OMX_ERRORTYPE +COmxILComponent::FreeBuffer( + OMX_HANDLETYPE aComponent, + OMX_U32 aPortIndex, + OMX_BUFFERHEADERTYPE* aBuffer) + { + DEBUG_PRINTF2(_L8("COmxILComponent::FreeBuffer : Handle[%X]"), aComponent); + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + FreeBuffer(aPortIndex, aBuffer); + return omxError; + } + +OMX_ERRORTYPE +COmxILComponent::EmptyThisBuffer( + OMX_HANDLETYPE aComponent, + OMX_BUFFERHEADERTYPE* aBuffer) + { + DEBUG_PRINTF2(_L8("COmxILComponent::EmptyThisBuffer : Handle[%X]"), aComponent); +#ifdef _OMXIL_COMMON_BUFFER_TRACING_ON + RDebug::Print(_L("COmxILComponent::EmptyThisBuffer component=0x%08X header=0x%08X port=%d flags=0x%X filledLen=%d timeStamp=%Ld"), + aComponent, aBuffer, aBuffer->nInputPortIndex, aBuffer->nFlags, aBuffer->nFilledLen, aBuffer->nTimeStamp); +#endif + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + EmptyThisBuffer(aBuffer); + + return omxError; + } + +OMX_ERRORTYPE +COmxILComponent::FillThisBuffer( + OMX_HANDLETYPE aComponent, + OMX_BUFFERHEADERTYPE* aBuffer) + { + DEBUG_PRINTF2(_L8("COmxILComponent::FillThisBuffer : Handle[%X]"), aComponent); +#ifdef _OMXIL_COMMON_BUFFER_TRACING_ON + RDebug::Print(_L("COmxILComponent::FillThisBuffer component=0x%08X header=0x%08X port=%d"), aComponent, aBuffer, aBuffer->nOutputPortIndex); +#endif + + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + FillThisBuffer(aBuffer); + + return omxError; + } + +OMX_ERRORTYPE +COmxILComponent::SetCallbacks( + OMX_HANDLETYPE aComponent, + OMX_CALLBACKTYPE* aCallbacks, + OMX_PTR aAppData) + { + DEBUG_PRINTF2(_L8("COmxILComponent::SetCallbacks : Handle[%X]"), aComponent); + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + SetCallbacks(const_cast(aCallbacks), aAppData); + return omxError; + } + +OMX_ERRORTYPE +COmxILComponent::ComponentDeInit( + OMX_HANDLETYPE aComponent) + { + DEBUG_PRINTF2(_L8("COmxILComponent::ComponentDeInit : Handle[%X]"), aComponent); + delete (static_cast( + (static_cast( + (static_cast(aComponent))-> + pComponentPrivate))->GetComponent())); + return OMX_ErrorNone; + } + +OMX_ERRORTYPE +COmxILComponent::UseEGLImage( + OMX_HANDLETYPE aComponent, + OMX_BUFFERHEADERTYPE** appBufferHdr, + OMX_U32 aPortIndex, + OMX_PTR aAppPrivate, + void* eglImage) + { + DEBUG_PRINTF2(_L8("COmxILComponent::UseEGLImage : Handle[%X]"), aComponent); + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + UseEGLImage(appBufferHdr, aPortIndex, aAppPrivate, eglImage); + return omxError; + } + +OMX_ERRORTYPE +COmxILComponent::ComponentRoleEnum( + OMX_HANDLETYPE aComponent, + OMX_U8* aRole, + OMX_U32 aIndex) + { + DEBUG_PRINTF2(_L8("COmxILComponent::ComponentRoleEnum : Handle[%X]"), aComponent); + OMX_ERRORTYPE omxError; + omxError = (static_cast + ((static_cast(aComponent))->pComponentPrivate))-> + ComponentRoleEnum(aRole, aIndex); + return omxError; + } + +/*static*/ EXPORT_C OMX_ERRORTYPE COmxILComponent::SymbianErrorToGetHandleError(TInt aSymbianError) + { + switch(aSymbianError) + { + case KErrNone: + return OMX_ErrorNone; + case KErrNoMemory: + return OMX_ErrorInsufficientResources; + case KErrArgument: + return OMX_ErrorBadParameter; + }; + + return OMX_ErrorUndefined; + }