diff -r a36789189b53 -r 095bea5f582e khronosfws/openmax_al/src/mediaplayer/xamediaplayer.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/mediaplayer/xamediaplayer.c	Tue Aug 31 15:43:02 2010 +0300
@@ -0,0 +1,620 @@
+/*
+ * 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 "xaplaybackrateitf.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_METADATAEXTRACTION,
+    &XA_IID_PLAYBACKRATE,
+    &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_VOLUMEITF)))
+                    {
+                    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_METADATAEXTRACTIONITF].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;
+        }
+
+    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_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_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);
+        }
+
+    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_PLAYBACKRATEITF:
+                    XAPlaybackRateItfImpl_Free(pItf);
+                    break;
+                case MP_CONFIGEXTENSIONITF:
+                    XAConfigExtensionsItfImpl_Free(pItf);
+                    break;
+                case MP_DYNAMICSOURCEITF:
+                    XADynamicSourceItfImpl_Free(pItf);
+                    break;
+                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);
+            }
+        }
+
+    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_PLAYBACKRATEITF:
+                mapEntry->pItf = XAPlaybackRateItfImpl_Create(pImpl);
+                break;
+            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_PLAYBACKRATEITF:
+                XAPlaybackRateItfImpl_Free(mapEntry->pItf);
+                break;
+            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;
+    }
+