/*
* 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: Media Player Object Implementation
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "xamediaplayer.h"
#include "xaplayitf.h"
#include "xaseekitf.h"
#include "xaprefetchstatusitf.h"
#include "xadynintmgmtitf.h"
#include "xavolumeitf.h"
#include "xametadataextractionitf.h"
#include "xametadatatraversalitf.h"
#include "xaplaybackrateitf.h"
#include "xaequalizeritf.h"
#include "xaimagecontrolsitf.h"
#include "xaimageeffectsitf.h"
#include "xavideopostprocessingitf.h"
#include "xaconfigextensionsitf.h"
#include "xathreadsafety.h"
#include "xametadataadaptation.h"
#include "xacapabilitiesmgr.h"
#include "xadynamicsourceitf.h"
#include "xastreaminformationitf.h"
#include "xanlinearvolumeitf.h"
#include "xanvolumeextitf.h"
extern void* vfHandle;
/* Static mapping of enumeration XAMediaPlayerInterfaces to interface iids */
static const XAInterfaceID* xaMediaPlayerItfIIDs[MP_ITFCOUNT] =
{
&XA_IID_OBJECT,
&XA_IID_DYNAMICINTERFACEMANAGEMENT,
&XA_IID_PLAY,
&XA_IID_SEEK,
&XA_IID_VOLUME,
&XA_IID_PREFETCHSTATUS,
&XA_IID_CONFIGEXTENSION,
&XA_IID_DYNAMICSOURCE,
&XA_IID_EQUALIZER,
&XA_IID_IMAGECONTROLS,
&XA_IID_IMAGEEFFECTS,
&XA_IID_METADATAEXTRACTION,
&XA_IID_METADATATRAVERSAL,
&XA_IID_PLAYBACKRATE,
&XA_IID_VIDEOPOSTPROCESSING,
&XA_IID_NOKIAVOLUMEEXT,
&XA_IID_NOKIALINEARVOLUME,
&XA_IID_STREAMINFORMATION
};
/* Global methods */
/* XAResult XAMediaPlayerImpl_CreateMediaPlayer
* Create object
*/
XAresult XAMediaPlayerImpl_CreateMediaPlayer(FrameworkMap* mapper,
XACapabilities* capabilities, XAObjectItf *pPlayer,
XADataSource *pDataSrc, XADataSource *pBankSrc,
XADataSink *pAudioSnk, XADataSink *pImageVideoSnk,
XADataSink *pVibra, XADataSink *pLEDArray, XAuint32 numInterfaces,
const XAInterfaceID *pInterfaceIds,
const XAboolean *pInterfaceRequired)
{
XAuint8 itfIdx = 0;
XAMediaType mediaType = XA_MEDIATYPE_UNKNOWN;
XAMediaPlayerImpl* pPlayerImpl = NULL;
FWMgrFwType fwType;
XAObjectItfImpl* pBaseObj = NULL;
const char *uri = NULL;
XAresult ret = XA_RESULT_SUCCESS;
XADataLocator_IODevice* tmpIODevice;
XADataLocator_IODevice locatorIODevice;
DEBUG_API("->XAMediaPlayerImpl_CreateMediaPlayer");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSMediaPlayer);
if (!pPlayer || !pDataSrc)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSMediaPlayer);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XAMediaPlayerImpl_CreateMediaPlayer");
return XA_RESULT_PARAMETER_INVALID;
}
/* check sink&source parameters */
ret = XACommon_ValidateDataLocator(6, pAudioSnk, pImageVideoSnk,
pDataSrc, pBankSrc, pVibra, pLEDArray);
if (ret != XA_RESULT_SUCCESS)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSMediaPlayer);
DEBUG_API("<-XAMediaPlayerImpl_CreateMediaPlayer");
return ret;
}
/* also, check source availability */
ret = XACommon_CheckDataSource(pDataSrc, &mediaType);
if (ret != XA_RESULT_SUCCESS)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSMediaPlayer);
DEBUG_API("<-XAMediaPlayerImpl_CreateMediaPlayer");
return ret;
}
/* instantiate object */
pPlayerImpl = (XAMediaPlayerImpl*) calloc(1, sizeof(XAMediaPlayerImpl));
if (!pPlayerImpl)
{
/* memory allocation failed */
XA_IMPL_THREAD_SAFETY_EXIT(XATSMediaPlayer);
DEBUG_API("<-XAMediaPlayerImpl_CreateMediaPlayer");
return XA_RESULT_MEMORY_FAILURE;
}
pBaseObj = &pPlayerImpl->baseObj;
/* Initialize base object default implementation */
XAObjectItfImpl_Init(pBaseObj, MP_ITFCOUNT, xaMediaPlayerItfIIDs,
XAMediaPlayerImpl_DoRealize, XAMediaPlayerImpl_DoResume,
XAMediaPlayerImpl_FreeResources);
/* Mark interfaces that need to be exposed */
/* Implicit and mandated interfaces */
pBaseObj->interfaceMap[MP_PLAYITF].required = XA_BOOLEAN_TRUE;
pBaseObj->interfaceMap[MP_DIMITF].required = XA_BOOLEAN_TRUE;
/* Explicit interfaces */
if ((numInterfaces != 0) && pInterfaceIds && pInterfaceRequired)
{
/* Check required interfaces */
for (itfIdx = 0; itfIdx < numInterfaces; itfIdx++)
{
/* If mapEntry is null then required interface is not supported.*/
XAObjItfMapEntry *entry = XAObjectItfImpl_GetItfEntry(
(XAObjectItf) &(pBaseObj), pInterfaceIds[itfIdx]);
if (!entry)
{
if (pInterfaceRequired[itfIdx])
{
/* required interface cannot be accommodated - fail creation */
DEBUG_ERR("Required interface not found - abort creation!");
ret = XA_RESULT_FEATURE_UNSUPPORTED;
break;
}
else
{
DEBUG_INFO("Requested (not required) interface not found - continue creation");
}
}
else
{ /* weed out unsupported content-aware itf's */
if ((mediaType == XA_MEDIATYPE_IMAGE && (entry->mapIdx
== MP_SEEKITF || entry->mapIdx == MP_EQUALIZERITF
|| entry->mapIdx == MP_VOLUMEITF)) || (mediaType
== XA_MEDIATYPE_AUDIO && (entry->mapIdx
== MP_IMAGECONTROLSITF || entry->mapIdx
== MP_IMAGEEFFECTSITF || entry->mapIdx
== MP_VIDEOPOSTPROCESSINGITF)))
{
entry->required = XA_BOOLEAN_FALSE;
if (pInterfaceRequired[itfIdx])
{
DEBUG_ERR("Required interface not supported for given media - abort creation!");
ret = XA_RESULT_FEATURE_UNSUPPORTED;
break;
}
}
else
{
entry->required = XA_BOOLEAN_TRUE;
}
}
}
}
if (ret != XA_RESULT_SUCCESS)
{ /* creation fails */
XAObjectItfImpl_Destroy((XAObjectItf) &(pBaseObj));
return ret;
}
/* Mark interfaces that can be handled dynamically */
/* Mandated dynamic itfs */
pBaseObj->interfaceMap[MP_EQUALIZERITF].isDynamic = XA_BOOLEAN_TRUE;
pBaseObj->interfaceMap[MP_IMAGEEFFECTSITF].isDynamic = XA_BOOLEAN_TRUE;
pBaseObj->interfaceMap[MP_METADATAEXTRACTIONITF].isDynamic
= XA_BOOLEAN_TRUE;
pBaseObj->interfaceMap[MP_METADATATRAVERSALITF].isDynamic
= XA_BOOLEAN_TRUE;
pBaseObj->interfaceMap[MP_PLAYBACKRATEITF].isDynamic = XA_BOOLEAN_TRUE;
/*Set ObjectItf to point to newly created object*/
*pPlayer = (XAObjectItf) &(pBaseObj->self);
/*initialize XAPlayerImpl variables */
pPlayerImpl->dataSrc = pDataSrc;
pPlayerImpl->bankSrc = pBankSrc;
pPlayerImpl->audioSnk = pAudioSnk;
pPlayerImpl->imageVideoSnk = pImageVideoSnk;
pPlayerImpl->vibra = pVibra;
pPlayerImpl->LEDArray = pLEDArray;
// Handle possible radio:
tmpIODevice = (XADataLocator_IODevice*) (pPlayerImpl->dataSrc->pLocator);
locatorIODevice = *tmpIODevice;
if (locatorIODevice.deviceType == XA_IODEVICE_RADIO)
{
fwType = (FWMgrFwType) FWMgrFWMMF;
}
else
{
/* Determine framework type that can handle recording */
fwType = (FWMgrFwType) FWMgrMOUnknown;
/**/
if (pDataSrc->pLocator)
{
XADataLocator_URI* dataLoc =
(XADataLocator_URI*) pDataSrc->pLocator;
if (dataLoc->locatorType == XA_DATALOCATOR_URI)
{
uri = (char*) dataLoc->URI;
}
}
fwType = XAFrameworkMgr_GetFramework(mapper, uri, FWMgrMOPlayer);
if (fwType == FWMgrMOUnknown)
{
ret = XA_RESULT_CONTENT_UNSUPPORTED;
XAObjectItfImpl_Destroy((XAObjectItf) &(pBaseObj));
XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );
DEBUG_API("<-XAMediaPlayerImpl_CreateMediaPlayer");
return ret;
}
} // end else
if (fwType == FWMgrFWMMF)
{
pPlayerImpl->adaptationCtxMMF = XAMediaPlayerAdaptMMF_Create(
pPlayerImpl->dataSrc, pPlayerImpl->bankSrc,
pPlayerImpl->audioSnk, pPlayerImpl->imageVideoSnk,
pPlayerImpl->vibra, pPlayerImpl->LEDArray);
pPlayerImpl->curAdaptCtx = pPlayerImpl->adaptationCtxMMF;
}
else
{
pPlayerImpl->adaptationCtxGst = XAMediaPlayerAdapt_Create(
pPlayerImpl->dataSrc, pPlayerImpl->bankSrc,
pPlayerImpl->audioSnk, pPlayerImpl->imageVideoSnk,
pPlayerImpl->vibra, pPlayerImpl->LEDArray);
pPlayerImpl->curAdaptCtx = pPlayerImpl->adaptationCtxGst;
}
pPlayerImpl->curAdaptCtx->capslist = capabilities;
pPlayerImpl->curAdaptCtx->fwtype = fwType;
XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );
DEBUG_API("<-XAMediaPlayerImpl_CreateMediaPlayer");
return XA_RESULT_SUCCESS;
}
/* XAResult XAMediaPlayerImpl_QueryNumSupportedInterfaces
* Statically query supported interfaces
*/
XAresult XAMediaPlayerImpl_QueryNumSupportedInterfaces(
XAuint32 * pNumSupportedInterfaces)
{
DEBUG_API("->XAMediaPlayerImpl_QueryNumSupportedInterfaces");
if (pNumSupportedInterfaces)
{
*pNumSupportedInterfaces = MP_ITFCOUNT;
DEBUG_API("<-XAMediaPlayerImpl_QueryNumSupportedInterfaces");
return XA_RESULT_SUCCESS;
}
else
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XAMediaPlayerImpl_QueryNumSupportedInterfaces");
return XA_RESULT_PARAMETER_INVALID;
}
}
/* XAResult XAMediaPlayerImpl_QuerySupportedInterfaces
* Statically query supported interfaces
*/
XAresult XAMediaPlayerImpl_QuerySupportedInterfaces(XAuint32 index,
XAInterfaceID * pInterfaceId)
{
DEBUG_API("->XAMediaPlayerImpl_QuerySupportedInterfaces");
if (index >= MP_ITFCOUNT || !pInterfaceId)
{
if (pInterfaceId)
{
*pInterfaceId = XA_IID_NULL;
}DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XAMediaPlayerImpl_QuerySupportedInterfaces");
return XA_RESULT_PARAMETER_INVALID;
}
else
{
*pInterfaceId = *(xaMediaPlayerItfIIDs[index]);
DEBUG_API("<-XAMediaPlayerImpl_QuerySupportedInterfaces");
return XA_RESULT_SUCCESS;
}
}
/*
* Realize the object
*/
XAresult XAMediaPlayerImpl_DoRealize(XAObjectItf self)
{
XAObjectItfImpl* pObj = (XAObjectItfImpl*) (*self);
XAMediaPlayerImpl* pImpl = (XAMediaPlayerImpl*) (pObj);
XAuint8 itfIdx = 0;
void *pItf = NULL;
XAresult ret = XA_RESULT_SUCCESS;
DEBUG_API("->XAMediaPlayerImpl_DoRealize");
XA_IMPL_THREAD_SAFETY_ENTRY( XATSMediaPlayer );
/* check casting from correct pointer type */
if (!pImpl || pObj != pImpl->baseObj.self)
{
/* invalid parameter */
XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XAMediaPlayerImpl_DoRealize");
return XA_RESULT_PARAMETER_INVALID;
}
/* Realize all implicit and explicitly wanted interfaces */
for (itfIdx = 0; itfIdx < MP_ITFCOUNT; itfIdx++)
{
if (!(pObj->interfaceMap[itfIdx].pItf)
&& pObj->interfaceMap[itfIdx].required)
{
switch (itfIdx)
{
case MP_DIMITF:
pItf = XADIMItfImpl_Create();
if (pItf)
{
XADIMItfImpl_Init(pItf, self,
XAMediaPlayerImpl_DoAddItf,
XAMediaPlayerImpl_DoResumeItf,
XAMediaPlayerImpl_DoRemoveItf);
}
break;
case MP_PLAYITF:
pItf = XAPlayItfImpl_Create(pImpl);
if (pImpl->dataSrc)
{
XAuint32 locType =
*((XAuint32*) (pImpl->dataSrc->pLocator));
if (locType == XA_DATALOCATOR_IODEVICE)
{
XADataLocator_IODevice
*ioDevice =
(XADataLocator_IODevice*) (pImpl->dataSrc->pLocator);
if (ioDevice->deviceType == XA_IODEVICE_CAMERA)
{
vfHandle = (void*) pItf;
DEBUG_INFO_A1("Stored view finder pointer to global address %x", vfHandle);
}
}
else
{
}
}
break;
case MP_VOLUMEITF:
pItf = XAVolumeItfImpl_Create(pImpl->curAdaptCtx);
break;
case MP_SEEKITF:
pItf = XASeekItfImpl_Create(pImpl);
break;
case MP_PREFETCHSTATUSITF:
pItf = XAPrefetchStatusItfImpl_Create(pImpl);
break;
case MP_METADATAEXTRACTIONITF:
pItf = XAMetadataExtractionItfImpl_Create(
pImpl->curAdaptCtx);
break;
case MP_METADATATRAVERSALITF:
pItf = XAMetadataTraversalItfImpl_Create(
pImpl->curAdaptCtx);
break;
case MP_PLAYBACKRATEITF:
pItf = XAPlaybackRateItfImpl_Create(pImpl);
break;
case MP_CONFIGEXTENSIONITF:
pItf = XAConfigExtensionsItfImpl_Create();
XAConfigExtensionsItfImpl_SetContext(pItf,
pImpl->curAdaptCtx);
break;
case MP_DYNAMICSOURCEITF:
pItf = XADynamicSourceItfImpl_Create(pImpl->curAdaptCtx);
break;
case MP_EQUALIZERITF:
pItf = XAEqualizerItfImpl_Create(pImpl->curAdaptCtx);
break;
#ifdef OMAX_CAMERABIN
case MP_IMAGECONTROLSITF:
pItf = XAImageControlsItfImpl_Create(pImpl->curAdaptCtx);
break;
case MP_IMAGEEFFECTSITF:
pItf = XAImageEffectsItfImpl_Create(pImpl->curAdaptCtx);
break;
case MP_VIDEOPOSTPROCESSINGITF:
pItf = XAVideoPostProcessingItfImpl_Create(pImpl->curAdaptCtx);
break;
#endif
case MP_NOKIAVOLUMEEXT:
pItf = XANokiaVolumeExtItfImpl_Create(pImpl->curAdaptCtx);
break;
case MP_NOKIALINEARVOLUME:
pItf = XANokiaLinearVolumeItfImpl_Create(
pImpl->curAdaptCtx);
break;
case MP_STREAMINFORMATIONITF:
pItf = XAStreamInformationItfImpl_Create(
pImpl->curAdaptCtx);
break;
default:
break;
}
if (!pItf)
{
/* Memory allocation failed */
XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );
DEBUG_ERR("XA_RESULT_MEMORY_FAILURE");
DEBUG_API("<-XAMediaPlayerImpl_DoRealize");
return XA_RESULT_MEMORY_FAILURE;
}
else
{
pObj->interfaceMap[itfIdx].pItf = pItf;
}
}
}
/* init adaptation */
if (pImpl->curAdaptCtx->fwtype == FWMgrFWMMF)
{
ret = XAMediaPlayerAdaptMMF_PostInit(
(XAAdaptationMMFCtx*) pImpl->adaptationCtxMMF);
}
else
{
ret = XAMediaPlayerAdapt_PostInit(
(XAAdaptationGstCtx*) pImpl->adaptationCtxGst);
}
if (ret != XA_RESULT_SUCCESS)
{
XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );
DEBUG_ERR("Adaptation init failed!");
DEBUG_API("<-XAMediaPlayerImpl_DoRealize");
return ret;
}
pObj->state = XA_OBJECT_STATE_REALIZED;
XA_IMPL_THREAD_SAFETY_EXIT( XATSMediaPlayer );
DEBUG_API("<-XAMediaPlayerImpl_DoRealize");
return XA_RESULT_SUCCESS;
}
/*
* Resume object
*/
XAresult XAMediaPlayerImpl_DoResume(XAObjectItf self)
{
DEBUG_API("->XAMediaPlayerImpl_DoResume");
DEBUG_API("<-XAMediaPlayerImpl_DoResume");
/* suspended state not supported by this implementation */
return XA_RESULT_PRECONDITIONS_VIOLATED;
}
/**
* void XAMediaPlayerImpl_FreeResources(XAObjectItf self)
* Description: Free all resources reserved at XAMediaPlayerImpl_DoRealize()
**/
void XAMediaPlayerImpl_FreeResources(XAObjectItf self)
{
XAObjectItfImpl* pObj = (XAObjectItfImpl*) (*self);
XAuint8 itfIdx = 0;
XAMediaPlayerImpl* pImpl = (XAMediaPlayerImpl*) pObj;
DEBUG_API("->XAMediaPlayerImpl_FreeResources");
XA_IMPL_THREAD_SAFETY_ENTRY_FOR_VOID_FUNCTIONS( XATSMediaPlayer );
assert(pObj && pImpl && pObj == pObj->self);
for (itfIdx = 0; itfIdx < MP_ITFCOUNT; itfIdx++)
{
void *pItf = pObj->interfaceMap[itfIdx].pItf;
if (pItf)
{
switch (itfIdx)
{
case MP_DIMITF:
XADIMItfImpl_Free(pItf);
break;
case MP_PLAYITF:
XAPlayItfImpl_Free(pItf);
break;
case MP_VOLUMEITF:
XAVolumeItfImpl_Free(pItf);
break;
case MP_SEEKITF:
XASeekItfImpl_Free(pItf);
break;
case MP_PREFETCHSTATUSITF:
XAPrefetchStatusItfImpl_Free(pItf);
break;
case MP_METADATAEXTRACTIONITF:
XAMetadataExtractionItfImpl_Free(pItf);
break;
case MP_METADATATRAVERSALITF:
XAMetadataTraversalItfImpl_Free(pItf);
break;
case MP_PLAYBACKRATEITF:
XAPlaybackRateItfImpl_Free(pItf);
break;
case MP_CONFIGEXTENSIONITF:
XAConfigExtensionsItfImpl_Free(pItf);
break;
case MP_DYNAMICSOURCEITF:
XADynamicSourceItfImpl_Free(pItf);
break;
case MP_EQUALIZERITF:
XAEqualizerItfImpl_Free(pItf);
break;
#ifdef OMAX_CAMERABIN
case MP_IMAGECONTROLSITF:
XAImageControlsItfImpl_Free(pItf);
break;
case MP_IMAGEEFFECTSITF:
XAImageEffectsItfImpl_Free(pItf);
break;
case MP_VIDEOPOSTPROCESSINGITF:
XAVideoPostProcessingItfImpl_Free(pItf);
break;
#endif
case MP_NOKIAVOLUMEEXT:
XANokiaVolumeExtItfImpl_Free(pItf);
break;
case MP_NOKIALINEARVOLUME:
XANokiaLinearVolumeItfImpl_Free(pItf);
break;
case MP_STREAMINFORMATIONITF:
XAStreamInformationItfImpl_Free(pItf);
break;
}
pObj->interfaceMap[itfIdx].pItf = NULL;
}
}
if (pImpl->curAdaptCtx)
{
if (pImpl->curAdaptCtx->fwtype == FWMgrFWMMF)
{
XAMediaPlayerAdaptMMF_Destroy(
(XAAdaptationMMFCtx*) pImpl->adaptationCtxMMF);
}
else
{
XAMediaPlayerAdapt_Destroy(
(XAAdaptationGstCtx*) pImpl->adaptationCtxGst);
}
}
XA_IMPL_THREAD_SAFETY_EXIT_FOR_VOID_FUNCTIONS( XATSMediaPlayer );
DEBUG_API("<-XAMediaPlayerImpl_FreeResources");
return;
}
/* XAMediaPlayerImpl_DoAddItf
* Dynamically add an interface, object specific parts
*/
XAresult XAMediaPlayerImpl_DoAddItf(XAObjectItf self,
XAObjItfMapEntry *mapEntry)
{
XAObjectItfImpl* pObj = (XAObjectItfImpl*) (*self);
XAMediaPlayerImpl* pImpl = (XAMediaPlayerImpl*) (pObj);
XAresult ret = XA_RESULT_SUCCESS;
DEBUG_API("->XAMediaPlayerImpl_DoAddItf");
if (mapEntry)
{
switch (mapEntry->mapIdx)
{
case MP_METADATAEXTRACTIONITF:
mapEntry->pItf = XAMetadataExtractionItfImpl_Create(
pImpl->curAdaptCtx);
break;
case MP_METADATATRAVERSALITF:
mapEntry->pItf = XAMetadataTraversalItfImpl_Create(
pImpl->curAdaptCtx);
break;
case MP_PLAYBACKRATEITF:
mapEntry->pItf = XAPlaybackRateItfImpl_Create(pImpl);
break;
case MP_EQUALIZERITF:
mapEntry->pItf
= XAEqualizerItfImpl_Create(pImpl->curAdaptCtx);
break;
#ifdef OMAX_CAMERABIN
case MP_IMAGEEFFECTSITF:
mapEntry->pItf = XAImageEffectsItfImpl_Create( pImpl->curAdaptCtx );
break;
#endif
default:
DEBUG_ERR("XAMediaPlayerImpl_DoAddItf unknown id")
;
ret = XA_RESULT_FEATURE_UNSUPPORTED;
break;
}
if (!mapEntry->pItf && ret == XA_RESULT_SUCCESS)
{
DEBUG_ERR("XAMediaPlayerImpl_DoAddItf itf creation failed");
ret = XA_RESULT_MEMORY_FAILURE;
}
}
else
{
ret = XA_RESULT_PARAMETER_INVALID;
}
DEBUG_API("<-XAMediaPlayerImpl_DoAddItf");
return ret;
}
/* XAMediaPlayerImpl_DoResumeItf
* Try to resume lost interface, object specific parts
*/
XAresult XAMediaPlayerImpl_DoResumeItf(XAObjectItf self,
XAObjItfMapEntry *mapEntry)
{
/* For now, no difference between suspended and unrealised itfs */
XAresult ret = XA_RESULT_SUCCESS;
DEBUG_API("->XAMediaPlayerImpl_DoResumeItf");
ret = XAMediaPlayerImpl_DoAddItf(self, mapEntry);
DEBUG_API("<-XAMediaPlayerImpl_DoResumeItf");
return ret;
}
/* XAMediaPlayerImpl_DoRemoveItf
* Dynamically remove an interface, object specific parts
*/
XAresult XAMediaPlayerImpl_DoRemoveItf(XAObjectItf self,
XAObjItfMapEntry *mapEntry)
{
XAresult ret = XA_RESULT_SUCCESS;
DEBUG_API("->XAMediaPlayerImpl_DoRemoveItf");
if (mapEntry)
{
switch (mapEntry->mapIdx)
{
case MP_METADATAEXTRACTIONITF:
XAMetadataExtractionItfImpl_Free(mapEntry->pItf);
break;
case MP_METADATATRAVERSALITF:
XAMetadataTraversalItfImpl_Free(mapEntry->pItf);
break;
case MP_PLAYBACKRATEITF:
XAPlaybackRateItfImpl_Free(mapEntry->pItf);
break;
case MP_EQUALIZERITF:
XAEqualizerItfImpl_Free(mapEntry->pItf);
break;
#ifdef OMAX_CAMERABIN
case MP_IMAGEEFFECTSITF:
XAImageEffectsItfImpl_Free(mapEntry->pItf);
break;
#endif
default:
DEBUG_ERR("XAMediaPlayerImpl_DoRemoveItf unknown id")
;
ret = XA_RESULT_FEATURE_UNSUPPORTED;
break;
}
mapEntry->pItf = NULL;
}
else
{
ret = XA_RESULT_PARAMETER_INVALID;
}
DEBUG_API("<-XAMediaPlayerImpl_DoRemoveItf");
return ret;
}