--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/omxil/mmilapi/unittest/test_plugins/omxildummyaudiodec/omxildummyaudiodec.cpp Wed Sep 01 12:38:50 2010 +0100
@@ -0,0 +1,544 @@
+// 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 "omxildummyaudiodec.h"
+#include "iltestuids.hrh"
+#include <openmax/il/loader/omxilsymbiancomponentif.h>
+#include <mmf/server/mmfdatabuffer.h>
+
+_LIT8(KDummyDecoderILComponentName,"OMX.SYMBIAN.AUDIO.DECODER.DUMMY");
+const TInt KMaxComponentNameLength = 128;
+
+OMXIL_COMPONENT_ECOM_ENTRYPOINT(KUidOmxILDummyAudioDec);
+
+const TUint32 KOMXALL = 0xFFFFFFFF;
+
+const TInt KMaxComponentRoleLength = 128;
+
+const TInt KIndexInputPort = 0;
+const TInt KIndexOutputPort = 1;
+
+// Set some dummy input and output buffer sizes
+const TInt KDummyDecoderInputBufferSize = 0x2000;
+const TInt KDummyDecoderOutputBufferSize = 0x4000;
+
+//_LIT(KDummyDecoder, "DummyDecoder");
+
+
+
+TInt COmxIlDummyAudioDec::CreateComponent(OMX_HANDLETYPE hComponent)
+ {
+ COmxIlDummyAudioDec* self = new COmxIlDummyAudioDec(hComponent);
+ if (self==NULL)
+ {
+ return KErrNoMemory;
+
+ }
+ else
+ {
+ return KErrNone;
+ }
+ }
+
+OMX_ERRORTYPE COmxIlDummyAudioDec::GetComponentVersion(
+ OMX_STRING pComponentName,
+ OMX_VERSIONTYPE* pComponentVersion,
+ OMX_VERSIONTYPE* pSpecVersion,
+ OMX_UUIDTYPE* pComponentUUID)
+ {
+ TPtr8 name(reinterpret_cast<TUint8*>(pComponentName),
+ KMaxComponentNameLength);
+ name.Copy(KDummyDecoderILComponentName);
+ name.PtrZ();
+
+ OMX_VERSIONTYPE compVer = { 1,0,0,0 };
+ OMX_VERSIONTYPE specVer = { 1,1,1,0 };
+
+ (*pComponentVersion) = compVer;
+ (*pSpecVersion) = specVer;
+
+ TPtr8 thisUid(reinterpret_cast<TUint8*>(*pComponentUUID), 128); //Maxsize fixed by Khronos;
+ thisUid = TPtr8(reinterpret_cast<TUint8*>(this), sizeof(TUint32));
+
+ return OMX_ErrorNone;
+ }
+
+
+COmxIlDummyAudioDec::COmxIlDummyAudioDec(OMX_HANDLETYPE hComponent)
+ :COmxComponentImpl(hComponent)
+ {
+ iState = OMX_StateLoaded;
+ }
+
+COmxIlDummyAudioDec::~COmxIlDummyAudioDec()
+ {
+ if (iState == OMX_StateExecuting)
+ {
+ iState = OMX_StateIdle;
+ }
+ }
+
+OMX_ERRORTYPE COmxIlDummyAudioDec::SendCommand(
+ OMX_COMMANDTYPE Cmd,
+ TUint32 nParam1,
+ TAny* /*pCmdData*/)
+ {
+ OMX_ERRORTYPE error = OMX_ErrorNone;
+ switch (Cmd)
+ {
+ case OMX_CommandStateSet:
+ {
+ OMX_STATETYPE state = (OMX_STATETYPE)nParam1;
+ if (state == iState)
+ {
+ error = OMX_ErrorSameState;
+ }
+ else
+ {
+ // notify client of the state change
+ switch (state)
+ {
+ case OMX_StateIdle:
+ case OMX_StatePause:
+ case OMX_StateExecuting:
+ break;
+ };
+ iState = state;
+
+ EventHandlerCallback(
+ OMX_EventCmdComplete,
+ OMX_CommandStateSet,
+ iState,
+ NULL);
+ }
+ break;
+ }
+
+ case OMX_CommandFlush:
+ {
+ if(nParam1 == KOMXALL)
+ {
+ EventHandlerCallback(
+ OMX_EventCmdComplete,
+ OMX_CommandFlush,
+ 0,
+ NULL);
+
+ EventHandlerCallback(
+ OMX_EventCmdComplete,
+ OMX_CommandFlush,
+ 1,
+ NULL);
+ }
+ else
+ {
+ EventHandlerCallback(
+ OMX_EventCmdComplete,
+ OMX_CommandFlush,
+ nParam1,
+ NULL);
+ }
+
+ break;
+ }
+ case OMX_CommandPortDisable:
+ {
+ if(nParam1 == KOMXALL)
+ {
+ EventHandlerCallback(
+ OMX_EventCmdComplete,
+ OMX_CommandPortDisable,
+ 0,
+ NULL);
+
+ EventHandlerCallback(
+ OMX_EventCmdComplete,
+ OMX_CommandPortDisable,
+ 1,
+ NULL);
+ }
+ else
+ {
+ EventHandlerCallback(
+ OMX_EventCmdComplete,
+ OMX_CommandPortDisable,
+ nParam1,
+ NULL);
+ }
+ break;
+ }
+ }
+ return error;
+ }
+
+OMX_ERRORTYPE COmxIlDummyAudioDec::GetParameter(
+ OMX_INDEXTYPE nParamIndex,
+ TAny* ComponentParameterStructure)
+ {
+ switch (nParamIndex)
+ {
+ case OMX_IndexParamAudioInit :
+ {
+ OMX_PORT_PARAM_TYPE* param = static_cast<OMX_PORT_PARAM_TYPE*>(ComponentParameterStructure);
+ param->nPorts = 2;
+ }
+ break;
+ case OMX_IndexParamPortDefinition:
+ {
+ OMX_PARAM_PORTDEFINITIONTYPE* portDef = static_cast<OMX_PARAM_PORTDEFINITIONTYPE*>(ComponentParameterStructure);
+ if (portDef->nPortIndex==0)
+ {
+ portDef->eDir = OMX_DirInput;
+ portDef->nBufferSize = KDummyDecoderInputBufferSize;
+ portDef->nBufferCountActual = iBufferCountActual0;
+ }
+ else
+ {
+ portDef->eDir = OMX_DirOutput;
+ portDef->nBufferSize = KDummyDecoderOutputBufferSize;
+ portDef->nBufferCountActual = iBufferCountActual1;
+ }
+ }
+ break;
+ default:
+ return OMX_ErrorUnsupportedIndex;
+ }
+ return OMX_ErrorNone;
+ }
+
+OMX_ERRORTYPE COmxIlDummyAudioDec::SetParameter(
+ OMX_INDEXTYPE nIndex,
+ TAny* ComponentParameterStructure)
+ {
+ ASSERT(iState == OMX_StateLoaded);
+ switch (nIndex)
+ {
+ case OMX_IndexParamAudioVorbis:
+ {
+ // Fake this is Audio Vorbis decoder for the purpose of testing
+ OMX_AUDIO_PARAM_VORBISTYPE* param = static_cast<OMX_AUDIO_PARAM_VORBISTYPE*>(ComponentParameterStructure);
+ switch(param->nPortIndex)
+ {
+ case 0: // Input port
+ {
+ // nothing to set
+ return OMX_ErrorNone;
+ }
+ case 1: // Output port
+ default:
+ {
+ return OMX_ErrorUnsupportedIndex;
+ }
+ };
+ }
+ case OMX_IndexParamAudioPcm:
+ {
+ OMX_AUDIO_PARAM_PCMMODETYPE* param = static_cast<OMX_AUDIO_PARAM_PCMMODETYPE*>(ComponentParameterStructure);
+ switch(param->nPortIndex)
+ {
+ case 1: // Output port = PCM
+ {
+ return OMX_ErrorNone;
+ }
+ case 0: // Input port
+ default:
+ {
+ return OMX_ErrorUnsupportedIndex;
+ }
+ };
+ }
+ case OMX_IndexParamPortDefinition:
+ {
+ OMX_PARAM_PORTDEFINITIONTYPE* portDef = static_cast<OMX_PARAM_PORTDEFINITIONTYPE*>(ComponentParameterStructure);
+ if (portDef->nPortIndex==0)
+ {
+ iBufferCountActual0 = portDef->nBufferCountActual;
+ }
+ else
+ {
+ iBufferCountActual1 = portDef->nBufferCountActual;
+ }
+ return OMX_ErrorNone;
+ }
+ default:
+ {
+ return OMX_ErrorUnsupportedIndex;
+ }
+ };
+ }
+
+OMX_ERRORTYPE COmxIlDummyAudioDec::GetConfig(
+ OMX_INDEXTYPE /*nIndex*/,
+ TAny* /*value*/)
+ {
+ return OMX_ErrorUnsupportedIndex;
+ }
+
+OMX_ERRORTYPE COmxIlDummyAudioDec::SetConfig(
+ OMX_INDEXTYPE /*nIndex*/,
+ TAny* /*value*/)
+ {
+ return OMX_ErrorUnsupportedIndex;
+ }
+
+OMX_ERRORTYPE COmxIlDummyAudioDec::GetExtensionIndex(
+ OMX_STRING /*parameterName*/,
+ OMX_INDEXTYPE* pIndexType)
+ {
+ // This test component returns always OMX_IndexParamPortDefinition
+ *pIndexType = OMX_IndexParamPortDefinition;
+
+ return OMX_ErrorNone;
+ }
+
+OMX_ERRORTYPE COmxIlDummyAudioDec::GetState(
+ OMX_STATETYPE* pState)
+ {
+ *pState = iState;
+ return OMX_ErrorNone;
+ }
+
+// To be implemented for DM4
+OMX_ERRORTYPE COmxIlDummyAudioDec::ComponentTunnelRequest(
+ OMX_HANDLETYPE /*hInput*/,
+ TUint32 /*nInputPort*/,
+ OMX_HANDLETYPE /*hOutput*/,
+ TUint32 /*nOutputPort*/,
+ OMX_TUNNELSETUPTYPE* /*pTunnelSetup*/)
+ {
+
+ // Fake everything as if it went fine
+ return OMX_ErrorNone;
+ }
+
+OMX_ERRORTYPE COmxIlDummyAudioDec::UseBuffer(
+ OMX_BUFFERHEADERTYPE** ppBufferHeader,
+ TUint32 nPortIndex,
+ TAny* pAppPrivate,
+ TUint32 nSizeBytes,
+ TUint8* pBuffer)
+ {
+ ASSERT(iState == OMX_StateLoaded);
+ *ppBufferHeader = new OMX_BUFFERHEADERTYPE;
+ if (*ppBufferHeader != NULL)
+ {
+ (*ppBufferHeader)->pBuffer = pBuffer;
+ (*ppBufferHeader)->pAppPrivate = pAppPrivate;
+ (*ppBufferHeader)->nAllocLen = nSizeBytes;
+ (*ppBufferHeader)->nFilledLen = 0;
+ (*ppBufferHeader)->nFlags = 0;
+ (*ppBufferHeader)->pInputPortPrivate = NULL;
+ (*ppBufferHeader)->pOutputPortPrivate = NULL;
+ }
+
+
+
+ if (*ppBufferHeader)
+ {
+ TPtr8 ptr(pBuffer,nSizeBytes,nSizeBytes);
+ CMMFBuffer* buffer = NULL;
+ TRAPD(err, buffer = CMMFPtrBuffer::NewL(ptr));
+ if (err != KErrNone)
+ {
+ return OMX_ErrorInsufficientResources;
+ }
+ switch (nPortIndex)
+ {
+ case KIndexInputPort:
+ {
+ (*ppBufferHeader)->pInputPortPrivate = buffer;
+ (*ppBufferHeader)->nInputPortIndex = nPortIndex;
+ }
+ break;
+ case KIndexOutputPort:
+ {
+ (*ppBufferHeader)->pOutputPortPrivate = buffer;
+ (*ppBufferHeader)->nOutputPortIndex = nPortIndex;
+ }
+ break;
+
+ }
+ return OMX_ErrorNone;
+ }
+ else
+ {
+ return OMX_ErrorInsufficientResources;
+ }
+ }
+
+OMX_ERRORTYPE COmxIlDummyAudioDec::AllocateBuffer(
+ OMX_BUFFERHEADERTYPE** pBuffer,
+ TUint32 nPortIndex,
+ TAny* pAppData,
+ TUint32 nSizeBytes)
+ {
+ ASSERT(iState == OMX_StateLoaded);
+
+ *pBuffer = new OMX_BUFFERHEADERTYPE;
+ if (*pBuffer != NULL)
+ {
+ CMMFDescriptorBuffer* buffer = NULL;
+ TRAPD(err, buffer = CMMFDescriptorBuffer::NewL(nSizeBytes));
+ if (err != KErrNone)
+ {
+ return OMX_ErrorInsufficientResources;
+ }
+ (*pBuffer)->pBuffer = const_cast<TUint8*>(buffer->Data().Ptr());
+ // store our allocated memory in component's private store
+ switch (nPortIndex)
+ {
+ case KIndexInputPort:
+ (*pBuffer)->pInputPortPrivate = buffer;
+ (*pBuffer)->pOutputPortPrivate = NULL;
+ break;
+ case KIndexOutputPort:
+ (*pBuffer)->pOutputPortPrivate = buffer;
+ (*pBuffer)->pInputPortPrivate = NULL;
+ break;
+ };
+
+
+ (*pBuffer)->nAllocLen = nSizeBytes;
+ (*pBuffer)->nFilledLen = 0;
+ (*pBuffer)->pAppPrivate = pAppData;
+ }
+
+ if (*pBuffer && (*pBuffer)->pBuffer)
+ {
+ return OMX_ErrorNone;
+ }
+ else
+ {
+ return OMX_ErrorInsufficientResources;
+ }
+ }
+
+OMX_ERRORTYPE COmxIlDummyAudioDec::FreeBuffer(
+ TUint32 nPortIndex,
+ OMX_BUFFERHEADERTYPE* pBuffer)
+ {
+ switch (nPortIndex)
+ {
+ case KIndexInputPort:
+ {
+ delete (static_cast<CMMFBuffer*>(pBuffer->pInputPortPrivate));
+ pBuffer->pInputPortPrivate = NULL;
+ break;
+ }
+ case KIndexOutputPort:
+ delete (static_cast<CMMFBuffer*>(pBuffer->pOutputPortPrivate));
+ pBuffer->pOutputPortPrivate = NULL;
+ break;
+
+ }
+ delete pBuffer;
+ return OMX_ErrorNone;
+ }
+OMX_ERRORTYPE COmxIlDummyAudioDec::EmptyThisBuffer(
+ OMX_BUFFERHEADERTYPE* pBuffer)
+ {
+ ASSERT(iState == OMX_StateExecuting ||
+ iState == OMX_StateIdle ||
+ iState == OMX_StatePause);
+ EmptyBufferDoneCallback(pBuffer);
+ return OMX_ErrorNone;
+ }
+OMX_ERRORTYPE COmxIlDummyAudioDec::FillThisBuffer(
+ OMX_BUFFERHEADERTYPE* pBuffer)
+ {
+ ASSERT(iState == OMX_StateExecuting ||
+ iState == OMX_StateIdle ||
+ iState == OMX_StatePause);
+
+ FillBufferDoneCallback(pBuffer);
+ return OMX_ErrorNone;
+ }
+
+OMX_ERRORTYPE COmxIlDummyAudioDec::SetCallbacks(
+ OMX_CALLBACKTYPE* pCallbacks,
+ TAny* pAppData)
+ {
+ iCallback = pCallbacks;
+ iAppData = pAppData;
+ return OMX_ErrorNone;
+ }
+
+OMX_ERRORTYPE COmxIlDummyAudioDec::ComponentRoleEnum(
+ OMX_OUT OMX_U8 *aRole,
+ OMX_IN OMX_U32 aIndex)
+ {
+ _LIT8(KFakeRole,"audio_decoder.vrb");
+
+ if (aIndex == 0)
+ {
+ TPtr8 ptr((TUint8*)aRole, 0, KMaxComponentRoleLength);
+ ptr.Copy(KFakeRole);
+ ptr.PtrZ();
+
+ return OMX_ErrorNone;
+ }
+ else
+ {
+ return OMX_ErrorBadParameter;
+ }
+ }
+
+// Callbacks for the Dummy Audio Decoder
+void COmxIlDummyAudioDec::EventHandlerCallback(
+ OMX_OUT OMX_EVENTTYPE eEvent,
+ OMX_OUT TUint32 nData1,
+ OMX_OUT TUint32 nData2,
+ OMX_OUT OMX_STRING cExtraInfo)
+ {
+ iCallback->EventHandler(
+ this,
+ iAppData,
+ eEvent,
+ nData1,
+ nData2,
+ cExtraInfo);
+ }
+
+void COmxIlDummyAudioDec::FillBufferDoneCallback(OMX_BUFFERHEADERTYPE* aBuffer)
+ {
+ iCallback->FillBufferDone(
+ *this,
+ iAppData,
+ aBuffer);
+ }
+
+void COmxIlDummyAudioDec::EmptyBufferDoneCallback(OMX_BUFFERHEADERTYPE* aBuffer)
+ {
+ iCallback->EmptyBufferDone(
+ *this,
+ iAppData,
+ aBuffer);
+ }
+
+// Component Entry Point
+OMX_ERRORTYPE OMX_ComponentInit(OMX_HANDLETYPE hComponent)
+ {
+ TInt err = COmxIlDummyAudioDec::CreateComponent(hComponent);
+ if (err == KErrNone)
+ return OMX_ErrorNone;
+ else
+ {
+ // return some problem
+ return OMX_ErrorInsufficientResources;
+
+ }
+ }
+