diff -r a36789189b53 -r 095bea5f582e khronosfws/openmax_al/src/engine/xaengineitf.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/khronosfws/openmax_al/src/engine/xaengineitf.c Tue Aug 31 15:43:02 2010 +0300 @@ -0,0 +1,432 @@ +/* + * Copyright (c) 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: Engine Interface Implementation + * + */ + +#include +#include +#include +#include "xaengineitf.h" +#include "xaobjects.h" +#include "xacapabilitiesmgr.h" +/*static XAchar implementationText[] = "Implementation does not conform to AL Spec";*/ + +/** + * XAEngineItfImpl* GetImpl(XAEngineItf self) + * Description: Validate interface pointer and cast it to implementation pointer. + **/ +static XAEngineItfImpl* GetImpl(XAEngineItf self) + { + if (self) + { + XAEngineItfImpl* impl = (XAEngineItfImpl*) (*self); + if (impl && (impl == impl->self)) + { + return impl; + } + } + return NULL; + } +/** + * Base interface XAEngineItf implementation + */ +XAresult XAEngineItfImpl_CreateCameraDevice(XAEngineItf self, + XAObjectItf *pDevice, XAuint32 deviceID, XAuint32 numInterfaces, + const XAInterfaceID *pInterfaceIds, + const XAboolean *pInterfaceRequired) + { +#ifdef OMAX_CAMERABIN + XAEngineItfImpl* impl = GetImpl(self); + return XACameraDeviceImpl_CreateCameraDevice( impl->mapper,impl->capabilities, + pDevice, deviceID,numInterfaces, + pInterfaceIds, pInterfaceRequired ); +#else + return XA_RESULT_FEATURE_UNSUPPORTED; +#endif + } + +XAresult XAEngineItfImpl_CreateRadioDevice(XAEngineItf self, + XAObjectItf *pDevice, XAuint32 numInterfaces, + const XAInterfaceID *pInterfaceIds, + const XAboolean *pInterfaceRequired) + { + return XARadioDeviceImpl_CreateRadioDevice( /*((XAEngineItfImpl*)self)->mapper,*/ + pDevice, numInterfaces, pInterfaceIds, pInterfaceRequired); + } + +XAresult XAEngineItfImpl_CreateLEDDevice(XAEngineItf self, + XAObjectItf *pDevice, XAuint32 deviceID, XAuint32 numInterfaces, + const XAInterfaceID *pInterfaceIds, + const XAboolean *pInterfaceRequired) + { + return XA_RESULT_FEATURE_UNSUPPORTED; + } + +XAresult XAEngineItfImpl_CreateVibraDevice(XAEngineItf self, + XAObjectItf *pDevice, XAuint32 deviceID, XAuint32 numInterfaces, + const XAInterfaceID *pInterfaceIds, + const XAboolean *pInterfaceRequired) + { + return XA_RESULT_FEATURE_UNSUPPORTED; + } + +XAresult XAEngineItfImpl_CreateMediaPlayer(XAEngineItf self, + XAObjectItf *pPlayer, XADataSource *pDataSrc, XADataSource *pBankSrc, + XADataSink *pAudioSnk, XADataSink *pImageVideoSnk, + XADataSink *pVibra, XADataSink *pLEDArray, XAuint32 numInterfaces, + const XAInterfaceID *pInterfaceIds, + const XAboolean *pInterfaceRequired) + { + XAEngineItfImpl* impl = GetImpl(self); + return XAMediaPlayerImpl_CreateMediaPlayer(impl->mapper, + impl->capabilities, pPlayer, pDataSrc, pBankSrc, pAudioSnk, + pImageVideoSnk, pVibra, pLEDArray, numInterfaces, pInterfaceIds, + pInterfaceRequired); + } + +XAresult XAEngineItfImpl_CreateMediaRecorder(XAEngineItf self, + XAObjectItf * pRecorder, XADataSource * pAudioSrc, + XADataSource * pImageVideoSrc, XADataSink * pDataSnk, + XAuint32 numInterfaces, const XAInterfaceID * pInterfaceIds, + const XAboolean * pInterfaceRequired) + { + XAEngineItfImpl* impl = GetImpl(self); + return XAMediaRecorderImpl_CreateMediaRecorder(impl->mapper, + impl->capabilities, pRecorder, pAudioSrc, pImageVideoSrc, + pDataSnk, numInterfaces, pInterfaceIds, pInterfaceRequired); + } + +XAresult XAEngineItfImpl_CreateOutputMix(XAEngineItf self, XAObjectItf *pMix, + XAuint32 numInterfaces, const XAInterfaceID *pInterfaceIds, + const XAboolean *pInterfaceRequired) + { + return XA_RESULT_FEATURE_UNSUPPORTED; + } + +XAresult XAEngineItfImpl_CreateMetadataExtractor(XAEngineItf self, + XAObjectItf *pMetadataExtractor, XADataSource *pDataSource, + XAuint32 numInterfaces, const XAInterfaceID *pInterfaceIds, + const XAboolean *pInterfaceRequired) + { + XAEngineItfImpl* impl = GetImpl(self); + return XAMetadataExtractorImpl_Create(impl->mapper, impl->capabilities, + pMetadataExtractor, pDataSource, numInterfaces, pInterfaceIds, + pInterfaceRequired); + } + +XAresult XAEngineItfImpl_CreateExtensionObject(XAEngineItf self, + XAObjectItf *pObject, void *pParameters, XAuint32 objectID, + XAuint32 numInterfaces, const XAInterfaceID *pInterfaceIds, + const XAboolean *pInterfaceRequired) + { + DEBUG_API("->XAEngineItfImpl_CreateExtensionObject"); + /* no supported extensions */ + DEBUG_API("<-XAEngineItfImpl_CreateExtensionObject - XA_RESULT_FEATURE_UNSUPPORTED"); + return XA_RESULT_FEATURE_UNSUPPORTED; + } + +XAresult XAEngineItfImpl_GetImplementationInfo(XAEngineItf self, + XAuint32 *pMajor, XAuint32 *pMinor, XAuint32 *pStep, + const XAchar *pImplementationText) + { + DEBUG_API("->XAEngineItfImpl_GetImplementationInfo"); + + if (!pMajor || !pMinor || !pStep) + { + DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); + DEBUG_API("<-XAEngineItfImpl_GetImplementationInfo"); + return XA_RESULT_PARAMETER_INVALID; + } + /* OpenMAX AL API ver 1.0.1 */ + *pMajor = 1; + *pMinor = 0; + *pStep = 1; + /*pImplementationText = (XAchar *) implementationText;*/ + + DEBUG_API("<-XAEngineItfImpl_GetImplementationInfo"); + return XA_RESULT_SUCCESS; + } + +XAresult XAEngineItfImpl_QuerySupportedProfiles(XAEngineItf self, + XAint16 *pProfilesSupported) + { + DEBUG_API("->XAEngineItfImpl_QuerySupportedProfiles"); + + if (!pProfilesSupported) + { + DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); + DEBUG_API("<-XAEngineItfImpl_QuerySupportedProfiles"); + return XA_RESULT_PARAMETER_INVALID; + } + /* NOTE: enable +MIDI when/if XMF issues solved + * XA_PROFILES_MEDIA_PLAYER | + * XA_PROFILES_MEDIA_PLAYER_RECORDER | + * XA_PROFILES_PLUS_MIDI; + */ + *pProfilesSupported = XA_PROFILES_MEDIA_PLAYER + | XA_PROFILES_MEDIA_PLAYER_RECORDER; + + DEBUG_API("<-XAEngineItfImpl_QuerySupportedProfiles"); + return XA_RESULT_SUCCESS; + } + +XAresult XAEngineItfImpl_QueryNumSupportedInterfaces(XAEngineItf self, + XAuint32 objectID, XAuint32 *pNumSupportedInterfaces) + { + XAresult res = XA_RESULT_SUCCESS; + DEBUG_API("->XAEngineItfImpl_QueryNumSupportedInterfaces"); + + if (!pNumSupportedInterfaces) + { + DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); + DEBUG_API("<-XAEngineItfImpl_QueryNumSupportedInterfaces"); + return XA_RESULT_PARAMETER_INVALID; + } + *pNumSupportedInterfaces = 0; + switch (objectID) + { + case XA_OBJECTID_ENGINE: + res = XAEngineImpl_QueryNumSupportedInterfaces( + pNumSupportedInterfaces); + break; + case XA_OBJECTID_MEDIAPLAYER: + res = XAMediaPlayerImpl_QueryNumSupportedInterfaces( + pNumSupportedInterfaces); + break; + case XA_OBJECTID_MEDIARECORDER: + res = XAMediaRecorderImpl_QueryNumSupportedInterfaces( + pNumSupportedInterfaces); + break; + case XA_OBJECTID_RADIODEVICE: + res = XARadioDeviceImpl_QueryNumSupportedInterfaces( + pNumSupportedInterfaces); + break; + case XA_OBJECTID_METADATAEXTRACTOR: + res = XAMetadataExtractorImpl_QueryNumSupportedInterfaces( + pNumSupportedInterfaces); + break; + default: + res = XA_RESULT_FEATURE_UNSUPPORTED; + break; + } + + DEBUG_API_A1("<-XAEngineItfImpl_QueryNumSupportedInterfaces %lu",res); + return res; + } + +XAresult XAEngineItfImpl_QuerySupportedInterfaces(XAEngineItf self, + XAuint32 objectID, XAuint32 index, XAInterfaceID *pInterfaceId) + { + XAresult res = XA_RESULT_SUCCESS; + DEBUG_API("->XAEngineItfImpl_QuerySupportedInterfaces"); + + if (!pInterfaceId) + { + DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); + DEBUG_API("<-XAEngineItfImpl_QuerySupportedInterfaces"); + return XA_RESULT_PARAMETER_INVALID; + } + *pInterfaceId = XA_IID_NULL; + switch (objectID) + { + case XA_OBJECTID_ENGINE: + res = XAEngineImpl_QuerySupportedInterfaces(index, pInterfaceId); + break; + case XA_OBJECTID_MEDIAPLAYER: + res = XAMediaPlayerImpl_QuerySupportedInterfaces(index, + pInterfaceId); + break; + case XA_OBJECTID_MEDIARECORDER: + res = XAMediaRecorderImpl_QuerySupportedInterfaces(index, + pInterfaceId); + break; + case XA_OBJECTID_RADIODEVICE: + res = XARadioDeviceImpl_QuerySupportedInterfaces(index, + pInterfaceId); + break; + case XA_OBJECTID_METADATAEXTRACTOR: + res = XAMetadataExtractorImpl_QuerySupportedInterfaces(index, + pInterfaceId); + break; + default: + res = XA_RESULT_FEATURE_UNSUPPORTED; + } + + DEBUG_API_A1("<-XAEngineItfImpl_QuerySupportedInterfaces %lu", res); + return res; + } + +XAresult XAEngineItfImpl_QueryLEDCapabilities(XAEngineItf self, + XAuint32 *pIndex, XAuint32 *pLEDDeviceID, + XALEDDescriptor *pDescriptor) + { + XAresult res = XA_RESULT_SUCCESS; + DEBUG_API("->XAEngineItfImpl_QueryLEDCapabilities"); + + if (!pDescriptor) + { /*query number of devices*/ + if (!pIndex) + { + DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); + DEBUG_API("<-XAEngineItfImpl_QueryLEDCapabilities"); + return XA_RESULT_PARAMETER_INVALID; + } + else + { + /* Number of devices */ + *pIndex = 0; + } + } + else + { + // return NotSupported below + res = XA_RESULT_FEATURE_UNSUPPORTED; + } + DEBUG_API("<-XAEngineItfImpl_QueryLEDCapabilities"); + return res; + } + +XAresult XAEngineItfImpl_QueryVibraCapabilities(XAEngineItf self, + XAuint32 *pIndex, XAuint32 *pVibraDeviceID, + XAVibraDescriptor *pDescriptor) + { + XAresult res = XA_RESULT_SUCCESS; + DEBUG_API("->XAEngineItfImpl_QueryVibraCapabilities"); + + if (!pDescriptor) + { /*query number of devices*/ + if (!pIndex) + { + DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); + DEBUG_API("<-XAEngineItfImpl_QueryVibraCapabilities"); + res = XA_RESULT_PARAMETER_INVALID; + } + else + { + /* Number of devices */ + *pIndex = 0; + } + } + else + { + // return NotSupported below + res = XA_RESULT_FEATURE_UNSUPPORTED; + } + + DEBUG_API("<-XAEngineItfImpl_QueryVibraCapabilities"); + return res; + } + +XAresult XAEngineItfImpl_QueryNumSupportedExtensions(XAEngineItf self, + XAuint32 *pNumExtensions) + { + DEBUG_API("->XAEngineItfImpl_QuerySupportedExtension"); + if (pNumExtensions == NULL) + { + DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); + DEBUG_API("<-XAEngineItfImpl_QuerySupportedExtension"); + return XA_RESULT_PARAMETER_INVALID; + } + /* no supported extensions */ + *pNumExtensions = 0; + DEBUG_API("<-XAEngineItfImpl_QuerySupportedExtension"); + return XA_RESULT_SUCCESS; + } + +XAresult XAEngineItfImpl_QuerySupportedExtension(XAEngineItf self, + XAuint32 index, XAchar *pExtensionName, XAint16 *pNameLength) + { + DEBUG_API("->XAEngineItfImpl_QuerySupportedExtension"); + /* no supported extensions => index is always wrong */ + DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); + DEBUG_API("<-XAEngineItfImpl_QuerySupportedExtension"); + return XA_RESULT_PARAMETER_INVALID; + } + +XAresult XAEngineItfImpl_IsExtensionSupported(XAEngineItf self, + const XAchar *pExtensionName, XAboolean *pSupported) + { + DEBUG_API("->XAEngineItfImpl_IsExtensionSupported"); + if (pSupported == NULL) + { + DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); + DEBUG_API("<-XAEngineItfImpl_IsExtensionSupported"); + return XA_RESULT_PARAMETER_INVALID; + } + /* no supported extensions */ + *pSupported = XA_BOOLEAN_FALSE; + DEBUG_API("<-XAEngineItfImpl_IsExtensionSupported"); + return XA_RESULT_SUCCESS; + } + +/** + * XAEngineItfImpl -specific methods + **/ +XAEngineItfImpl* XAEngineItfImpl_Create(FrameworkMap* fwkmapper, + XACapabilities* capabilities) + { + XAEngineItfImpl* self = (XAEngineItfImpl*) calloc(1, + sizeof(XAEngineItfImpl)); + DEBUG_API("->XAEngineItfImpl_Create"); + + if (self) + { + /* init itf default implementation */ + self->itf.CreateCameraDevice = XAEngineItfImpl_CreateCameraDevice; + self->itf.CreateRadioDevice = XAEngineItfImpl_CreateRadioDevice; + self->itf.CreateLEDDevice = XAEngineItfImpl_CreateLEDDevice; + self->itf.CreateVibraDevice = XAEngineItfImpl_CreateVibraDevice; + self->itf.CreateMediaPlayer = XAEngineItfImpl_CreateMediaPlayer; + self->itf.CreateMediaRecorder = XAEngineItfImpl_CreateMediaRecorder; + self->itf.CreateOutputMix = XAEngineItfImpl_CreateOutputMix; + self->itf.CreateMetadataExtractor + = XAEngineItfImpl_CreateMetadataExtractor; + self->itf.CreateExtensionObject + = XAEngineItfImpl_CreateExtensionObject; + self->itf.GetImplementationInfo + = XAEngineItfImpl_GetImplementationInfo; + self->itf.QuerySupportedProfiles + = XAEngineItfImpl_QuerySupportedProfiles; + self->itf.QueryNumSupportedInterfaces + = XAEngineItfImpl_QueryNumSupportedInterfaces; + self->itf.QuerySupportedInterfaces + = XAEngineItfImpl_QuerySupportedInterfaces; + self->itf.QueryLEDCapabilities = XAEngineItfImpl_QueryLEDCapabilities; + self->itf.QueryVibraCapabilities + = XAEngineItfImpl_QueryVibraCapabilities; + self->itf.QueryNumSupportedExtensions + = XAEngineItfImpl_QueryNumSupportedExtensions; + self->itf.QuerySupportedExtension + = XAEngineItfImpl_QuerySupportedExtension; + self->itf.IsExtensionSupported = XAEngineItfImpl_IsExtensionSupported; + self->mapper = fwkmapper; + self->capabilities = capabilities; + self->xyz = 50; + self->self = self; + } + DEBUG_API("<-XAEngineItfImpl_Create"); + return self; + } + +void XAEngineItfImpl_Free(XAEngineItfImpl* self) + { + DEBUG_API("->XAEngineItfImpl_Free"); + if(self) + { + assert(self==self->self); + free(self); + } + DEBUG_API("<-XAEngineItfImpl_Free"); + }