/*
* 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:
*
*/
#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;
}