/*
* 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: Metadata Extraction Interface Implementation
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "xametadataextractionitf.h"
#include "xadebug.h"
#include "xametadataadaptation.h"
#include "xaadaptationmmf.h"
#include "xametadataadaptctxmmf.h"
#include "xamediaplayeradaptctxmmf.h"
#include "cmetadatautilityitf.h"
/* XAMetadataExtractionItfImpl* GetImpl(XAMetadataExtractionItf self)
* Description: Validate interface pointer and cast it to implementation pointer.
**/
static XAMetadataExtractionItfImpl* GetImpl(XAMetadataExtractionItf self)
{
if (self)
{
XAMetadataExtractionItfImpl* impl =
(XAMetadataExtractionItfImpl*) (*self);
if (impl && (impl == impl->self))
{
return impl;
}
}
return NULL;
}
static void* GetMetadataUtilityContext(XAAdaptationMMFCtx* adaptCtx)
{
if (adaptCtx)
{
switch (adaptCtx->baseObj.ctxId)
{
case XAMediaPlayerAdaptation:
return ((XAMediaPlayerAdaptationMMFCtx*) adaptCtx)->mmfMetadataContext;
case XAMDAdaptation:
return ((XAMetadataAdaptationMMFCtx*) adaptCtx)->mmfContext;
default:
break;
}
}
return NULL;
}
/*****************************************************************************
* Base interface XAMetadataExtractionItf implementation
*****************************************************************************/
/*
* Returns the number of metadata items within the current scope of the object.
* @XAuint32 *pItemCount
* Number of metadata items. Must be non-NULL
*/
XAresult XAMetadataExtractionItfImpl_GetItemCount(
XAMetadataExtractionItf self, XAuint32 *pItemCount)
{
XAMetadataExtractionItfImpl *impl = NULL;
XAresult res = XA_RESULT_SUCCESS;
DEBUG_API("->XAMetadataExtractionItfImpl_GetItemCount");
impl = GetImpl(self);
/* check parameters */
if (!impl || !pItemCount)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
res = XA_RESULT_PARAMETER_INVALID;
}
else
{
if (impl->adaptCtx)
{
if (impl->adaptCtx->fwtype == FWMgrFWMMF)
{
void *mmfCtx = GetMetadataUtilityContext(
(XAAdaptationMMFCtx*) impl->adaptCtx);
if (mmfCtx)
{
res = mmf_get_item_count(mmfCtx, pItemCount);
}
else
{
res = XA_RESULT_PARAMETER_INVALID;
}
}
else
{
if (impl->filteringOn)
{
*pItemCount = impl->filteredcount;
}
else
{
*pItemCount = impl->currentTags.itemcount;
}
res = XA_RESULT_SUCCESS;
}
}
else
{
res = XA_RESULT_INTERNAL_ERROR;
}
DEBUG_INFO_A1("itemCount = %d", (int)*pItemCount);
}
DEBUG_API_A1("<-XAMetadataExtractionItfImpl_GetItemCount (%d)", (int)res);
return res;
}
/*
* Returns the byte size of a given metadata key
*
* @XAuint32 index
* Metadata item Index. Range is [0, GetItemCount)
* @XAuint32 *pKeySize
* Address to store key size. size must be greater than 0. Must be non-NULL
*/
XAresult XAMetadataExtractionItfImpl_GetKeySize(XAMetadataExtractionItf self,
XAuint32 index, XAuint32 *pKeySize)
{
XAMetadataExtractionItfImpl *impl = NULL;
XAresult res = XA_RESULT_SUCCESS;
XAuint32 newidx = 0;
DEBUG_API("->XAMetadataExtractionItfImpl_GetKeySize");
impl = GetImpl(self);
if (!impl || !pKeySize)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XAMetadataExtractionItfImpl_GetKeySize");
return XA_RESULT_PARAMETER_INVALID;
}
*pKeySize = 0;
if (impl->adaptCtx && impl->adaptCtx->fwtype == FWMgrFWMMF)
{
void *mmfCtx = GetMetadataUtilityContext(
(XAAdaptationMMFCtx*) impl->adaptCtx);
if (mmfCtx)
{
res = mmf_get_key_size(mmfCtx, index, pKeySize);
}
else
{
res = XA_RESULT_PARAMETER_INVALID;
}
}
else
{
/* check index and return unfiltered index */
if (CheckAndUnfilterIndex(impl, index, &newidx) != XA_RESULT_SUCCESS)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XAMetadataExtractionItfImpl_GetKeySize");
return XA_RESULT_PARAMETER_INVALID;
}
/* size = size of struct + size of data - 1 (struct size already includes one char) */
*pKeySize = sizeof(XAMetadataInfo)
+ impl->currentTags.mdeKeys[newidx]->size - 1;
}
DEBUG_API_A1("<-XAMetadataExtractionItfImpl_GetKeySize (%d)", (int)res);
return res;
}
/*
* Returns a XAMetadataInfo structure and associated data referenced by the structure for a key.
* @XAuint32 index
* Metadata item Index. Range is [0, GetItemCount())
* @XAuint32 keySize
* Size of the memory block passed as key. Range is [1, GetKeySize].
* @XAMetadataInfo *pKey
* Address to store the key. Must be non-NULL
*/
XAresult XAMetadataExtractionItfImpl_GetKey(XAMetadataExtractionItf self,
XAuint32 index, XAuint32 keySize, XAMetadataInfo *pKey)
{
XAMetadataExtractionItfImpl *impl = NULL;
XAresult res = XA_RESULT_SUCCESS;
XAuint32 newidx = 0;
XAuint32 neededsize = 0;
XAuint32 newdatasize = 0;
DEBUG_API("->XAMetadataExtractionItfImpl_GetKey");
impl = GetImpl(self);
if (!impl || !pKey)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XAMetadataExtractionItfImpl_GetKey");
return XA_RESULT_PARAMETER_INVALID;
}
memset(pKey, 0, keySize);
if (impl->adaptCtx && impl->adaptCtx->fwtype == FWMgrFWMMF)
{
void *mmfCtx = GetMetadataUtilityContext(
(XAAdaptationMMFCtx*) impl->adaptCtx);
if (mmfCtx)
{
res = mmf_get_key(mmfCtx, index, keySize, pKey);
}
else
{
res = XA_RESULT_PARAMETER_INVALID;
}
}
else
{
/* check index and return unfiltered index */
if (CheckAndUnfilterIndex(impl, index, &newidx) != XA_RESULT_SUCCESS)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XAMetadataExtractionItfImpl_GetKey");
return XA_RESULT_PARAMETER_INVALID;
}
/* needed size = size of struct + size of data - 1 (struct size already includes one char) */
neededsize = sizeof(XAMetadataInfo)
+ impl->currentTags.mdeKeys[newidx]->size - 1;
if (keySize < neededsize)
{ /* cannot fit all of key data */
newdatasize = impl->currentTags.mdeKeys[newidx]->size
- (neededsize - keySize);
DEBUG_ERR("XA_RESULT_BUFFER_INSUFFICIENT");
res = XA_RESULT_BUFFER_INSUFFICIENT;
}
else
{
newdatasize = impl->currentTags.mdeKeys[newidx]->size;
res = XA_RESULT_SUCCESS;
}
/* copy data up to given size */
memcpy(pKey, impl->currentTags.mdeKeys[newidx], keySize - 1);
/* ensure null-termination */
memset(pKey->data + newdatasize - 1, 0, 1);
pKey->size = newdatasize;
}
DEBUG_API_A1("<-XAMetadataExtractionItfImpl_GetKey (%d)", (int)res);
return res;
}
/*
* Returns the byte size of a given metadata value
* @XAuint32 index
* Metadata item Index. Range is [0, GetItemCount())
* @XAuint32 *pValueSize
* Address to store value size. size must be greater than 0. Must be non-NULL
*/
XAresult XAMetadataExtractionItfImpl_GetValueSize(
XAMetadataExtractionItf self, XAuint32 index, XAuint32 *pValueSize)
{
XAMetadataExtractionItfImpl *impl = NULL;
XAresult res = XA_RESULT_SUCCESS;
XAuint32 newidx = 0;
DEBUG_API("->XAMetadataExtractionItfImpl_GetValueSize");
impl = GetImpl(self);
if (!impl || !pValueSize)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XAMetadataExtractionItfImpl_GetValueSize");
return XA_RESULT_PARAMETER_INVALID;
}
*pValueSize = 0;
if (impl->adaptCtx && impl->adaptCtx->fwtype == FWMgrFWMMF)
{
void *mmfCtx = GetMetadataUtilityContext(
(XAAdaptationMMFCtx*) impl->adaptCtx);
if (mmfCtx)
{
res = mmf_get_value_size(mmfCtx, index, pValueSize);
}
else
{
res = XA_RESULT_PARAMETER_INVALID;
}
}
else
{
/* check index and return unfiltered index */
if (CheckAndUnfilterIndex(impl, index, &newidx) != XA_RESULT_SUCCESS)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XAMetadataExtractionItfImpl_GetValueSize");
return XA_RESULT_PARAMETER_INVALID;
}
/* size = size of struct + size of data - 1 (struct size already includes one char) */
*pValueSize = sizeof(XAMetadataInfo)
+ impl->currentTags.mdeValues[newidx]->size - 1;
}
DEBUG_API_A1("<-XAMetadataExtractionItfImpl_GetValueSize (%d)", (int)res);
return res;
}
/*
* Returns a XAMetadataInfo structure and associated data referenced by the structure for a value.
* @XAuint32 index
* Metadata item Index. Range is [0, GetItemCount())
* @XAuint32 valueSize
* Size of the memory block passed as value. Range is [0, GetValueSize]
* @XAMetadataInfo *pValue
* Address to store the value. Must be non-NULL
*/
XAresult XAMetadataExtractionItfImpl_GetValue(XAMetadataExtractionItf self,
XAuint32 index, XAuint32 valueSize, XAMetadataInfo *pValue)
{
XAMetadataExtractionItfImpl *impl = NULL;
XAresult res = XA_RESULT_SUCCESS;
XAuint32 newidx = 0;
XAuint32 neededsize = 0;
XAuint32 newdatasize = 0;
DEBUG_API("->XAMetadataExtractionItfImpl_GetValue");
impl = GetImpl(self);
if (!impl || !pValue)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XAMetadataExtractionItfImpl_GetValue");
return XA_RESULT_PARAMETER_INVALID;
}
memset(pValue, 0, valueSize);
if (impl->adaptCtx && impl->adaptCtx->fwtype == FWMgrFWMMF)
{
void *mmfCtx = GetMetadataUtilityContext(
(XAAdaptationMMFCtx*) impl->adaptCtx);
if (mmfCtx)
{
res = mmf_get_value(mmfCtx, index, valueSize, pValue);
}
else
{
res = XA_RESULT_PARAMETER_INVALID;
}
}
else
{
/* check index and return unfiltered index */
if (CheckAndUnfilterIndex(impl, index, &newidx) != XA_RESULT_SUCCESS)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XAMetadataExtractionItfImpl_GetValue");
return XA_RESULT_PARAMETER_INVALID;
}
/* needed size = size of struct + size of data - 1 (struct size already includes one char) */
neededsize = sizeof(XAMetadataInfo)
+ impl->currentTags.mdeValues[newidx]->size - 1;
if (valueSize < neededsize)
{ /* cannot fit all of key data */
newdatasize = impl->currentTags.mdeValues[newidx]->size
- (neededsize - valueSize);
DEBUG_ERR("XA_RESULT_BUFFER_INSUFFICIENT");
res = XA_RESULT_BUFFER_INSUFFICIENT;
}
else
{
newdatasize = impl->currentTags.mdeValues[newidx]->size;
res = XA_RESULT_SUCCESS;
}
/* copy data up to given size */
memcpy(pValue, impl->currentTags.mdeValues[newidx], valueSize - 1);
/* ensure null-termination */
memset(pValue->data + newdatasize - 1, 0, 1);
pValue->size = newdatasize;
}
DEBUG_API_A1("<-XAMetadataExtractionItfImpl_GetValue (%d)",(int)res);
return res;
}
/*
* Adds a filter for a specific key
* @XAuint32 keySize
* Size in bytes, of the pKey parameter. Ignored if filtering by key is disabled
* @const void *pKey
* The key to filter by. The entire key must match. Ignored if filtering by key is disabled.
* @XAuint32 keyEncoding
* Character encoding of the pKey parameter. Ignored if filtering by key is disabled
* @const XAchar *pValueLangCountry
* Language / country code of the value to filter by. Ignored if filtering by language / country is disabled
* @XAuint32 valueEncoding
* Encoding of the value to filter by. Ignored if filtering by encoding is disabled
* @XAuint8 filterMask
* Bitmask indicating which criteria to filter by. Should be one of the XA_METADATA_FILTER macros
*/
XAresult XAMetadataExtractionItfImpl_AddKeyFilter(
XAMetadataExtractionItf self, XAuint32 keySize, const void *pKey,
XAuint32 keyEncoding, const XAchar *pValueLangCountry,
XAuint32 valueEncoding, XAuint8 filterMask)
{
XAresult res = XA_RESULT_SUCCESS;
XAuint32 idx = 0;
XAuint8 matchMask = 0;
XAMetadataExtractionItfImpl *impl = NULL;
const XAchar* parsedkey;
impl = GetImpl(self);
DEBUG_API("->XAMetadataExtractionItfImpl_AddKeyFilter");
if (!impl)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-XAMetadataExtractionItfImpl_AddKeyFilter");
return XA_RESULT_PARAMETER_INVALID;
}
else
{
if (impl->adaptCtx && impl->adaptCtx->fwtype == FWMgrFWMMF)
{
DEBUG_API("<-XAMetadataExtractionItfImpl_AddKeyFilter Not Supported in MMF");
res = XA_RESULT_PARAMETER_INVALID;
}
else
{
impl->filteringOn = XA_BOOLEAN_TRUE;
for (idx = 0; idx < impl->currentTags.itemcount; idx++)
{
if ((filterMask & XA_METADATA_FILTER_KEY) && pKey)
{
parsedkey = XAMetadataAdapt_ParseKhronosKey(pKey);
if (strcmp((char*) parsedkey,
(char*) impl->currentTags.mdeKeys[idx]->data)
== 0)
{
matchMask |= XA_METADATA_FILTER_KEY;
}
}
if (filterMask & XA_METADATA_FILTER_LANG && pValueLangCountry)
{
if (strcmp(
(char*) pValueLangCountry,
(char*) impl->currentTags.mdeKeys[idx]->langCountry)
== 0)
{
matchMask |= XA_METADATA_FILTER_LANG;
}
}
if (filterMask & XA_METADATA_FILTER_ENCODING)
{
if (keyEncoding
== impl->currentTags.mdeKeys[idx]->encoding)
{
matchMask |= XA_METADATA_FILTER_ENCODING;
}
if (valueEncoding
== impl->currentTags.mdeValues[idx]->encoding)
{
matchMask |= XA_METADATA_FILTER_ENCODING;
}
}
/* check if all filters apply */
if (filterMask == matchMask)
{
if (impl->tagmatchesfilter[idx] == XA_BOOLEAN_FALSE)
{
impl->tagmatchesfilter[idx] = XA_BOOLEAN_TRUE;
impl->filteredcount++;
}
}
/*reset matchmask*/
matchMask = 0;
}
}
}
DEBUG_API_A1("<-XAMetadataExtractionItfImpl_AddKeyFilter (%d)", (int)res);
return res;
}
/*
* Clears the key filter
*/
XAresult XAMetadataExtractionItfImpl_ClearKeyFilter(
XAMetadataExtractionItf self)
{
XAMetadataExtractionItfImpl *impl = NULL;
XAresult res = XA_RESULT_SUCCESS;
XAuint32 idx = 0;
DEBUG_API("->XAMetadataExtractionItfImpl_ClearKeyFilter");
impl = GetImpl(self);
if (!impl)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
res = XA_RESULT_PARAMETER_INVALID;
}
else
{
if (impl->adaptCtx && impl->adaptCtx->fwtype == FWMgrFWMMF)
{
DEBUG_API("<-XAMetadataExtractionItfImpl_ClearKeyFilter Not Supported in MMF");
res = XA_RESULT_PARAMETER_INVALID;
}
else
{
if (impl->tagmatchesfilter)
{
for (idx = 0; idx < impl->currentTags.itemcount; idx++)
{
impl->tagmatchesfilter[idx] = XA_BOOLEAN_FALSE;
}
}
impl->filteredcount = 0;
impl->filteringOn = XA_BOOLEAN_FALSE;
}
}
DEBUG_API_A1("<-XAMetadataExtractionItfImpl_ClearKeyFilter (%d)", (int)res);
return res;
}
/*****************************************************************************
* XAMetadataExtractionItfImpl -specific methods
*****************************************************************************/
/* XAMetadataExtractionItfImpl* XAMetadataExtractionItfImpl_Create()
* Description: Allocate and initialize XAMetadataExtractionItfImpl
*/
XAMetadataExtractionItfImpl* XAMetadataExtractionItfImpl_Create(
XAAdaptationBaseCtx *adaptCtx)
{
XAMetadataExtractionItfImpl *self = NULL;
DEBUG_API("->XAMetadataExtractionItfImpl_Create");
self = (XAMetadataExtractionItfImpl*) calloc(1,
sizeof(XAMetadataExtractionItfImpl));
if (self)
{
/* init itf default implementation */
self->itf.GetItemCount = XAMetadataExtractionItfImpl_GetItemCount;
self->itf.GetKeySize = XAMetadataExtractionItfImpl_GetKeySize;
self->itf.GetKey = XAMetadataExtractionItfImpl_GetKey;
self->itf.GetValueSize = XAMetadataExtractionItfImpl_GetValueSize;
self->itf.GetValue = XAMetadataExtractionItfImpl_GetValue;
self->itf.AddKeyFilter = XAMetadataExtractionItfImpl_AddKeyFilter;
self->itf.ClearKeyFilter = XAMetadataExtractionItfImpl_ClearKeyFilter;
/* init variables */
self->filteredcount = 0;
self->filteringOn = XA_BOOLEAN_FALSE;
self->adaptCtx = adaptCtx;
if (self->adaptCtx->fwtype != FWMgrFWMMF)
{
XAAdaptationBase_AddEventHandler(adaptCtx,
&XAMetadataExtractionItfImp_AdaptCb, XA_METADATAEVENTS,
self);
}
self->self = self;
}
DEBUG_API("<-XAMetadataExtractionItfImpl_Create");
return self;
}
/* void XAMetadataExtractionItfImpl_Free(XAMetadataExtractionItfImpl* self)
* Description: Free all resources reserved at XAMetadataExtractionItfImpl_Create
*/
void XAMetadataExtractionItfImpl_Free(XAMetadataExtractionItfImpl* self)
{
DEBUG_API("->XAMetadataExtractionItfImpl_Free");
assert(self==self->self);
if (self->adaptCtx->fwtype != FWMgrFWMMF)
{
XAAdaptationBase_RemoveEventHandler(self->adaptCtx,
&XAMetadataExtractionItfImp_AdaptCb);
XAMetadataAdapt_FreeImplTagList(&(self->currentTags), XA_BOOLEAN_TRUE);
if (self->tagmatchesfilter)
{
free(self->tagmatchesfilter);
}
}
free(self);
DEBUG_API("<-XAMetadataExtractionItfImpl_Free");
}
/* With this method, adaptation infroms that new tags are found (e.g. if source,
* has changed, live stream contains metadata...)
*/
void XAMetadataExtractionItfImp_AdaptCb(void *pHandlerCtx,
XAAdaptEvent *event)
{
XAMetadataExtractionItfImpl* impl = NULL;
DEBUG_API("->XAMetadataExtractionItfImp_AdaptCb");
impl = (XAMetadataExtractionItfImpl*) pHandlerCtx;
if (!impl)
{
DEBUG_ERR("XAMetadataExtractionItfImp_AdaptCb, invalid context pointer!");
DEBUG_API("<-XAMetadataExtractionItfImp_AdaptCb");
return;
}
if (event && event->eventid == XA_ADAPT_MDE_TAGS_AVAILABLE)
{
/* get the tag list */
XAMetadataExtractionItfAdapt_FillTagList(
(XAAdaptationGstCtx*) impl->adaptCtx, &(impl->currentTags));
if (impl->tagmatchesfilter)
{
free(impl->tagmatchesfilter);
}
impl->tagmatchesfilter = calloc(impl->currentTags.itemcount,
sizeof(XAboolean));
impl->filteredcount = 0;
}
else
{
DEBUG_INFO("unhandled");
}
DEBUG_API("<-XAMetadataExtractionItfImp_AdaptCb");
}
/* For given index over filtered array, return index over whole array
*/
XAresult CheckAndUnfilterIndex(XAMetadataExtractionItfImpl *impl,
XAuint32 oldidx, XAuint32 *newidx)
{
DEBUG_API("->CheckAndUnfilterIndex");
if (impl->filteringOn)
{
XAint16 i = -1;
if (oldidx >= impl->filteredcount)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-CheckAndUnfilterIndex");
return XA_RESULT_PARAMETER_INVALID;
}
*newidx = 0;
while (*newidx < impl->currentTags.itemcount)
{
if (impl->tagmatchesfilter[*newidx])
i++;
if (i < oldidx)
(*newidx)++;
else
break;
}
if (*newidx == impl->currentTags.itemcount)
{
/* should not end up here */
*newidx = 0;
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-CheckAndUnfilterIndex");
return XA_RESULT_PARAMETER_INVALID;
}
}
else
{
if (oldidx >= impl->currentTags.itemcount)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
DEBUG_API("<-CheckAndUnfilterIndex");
return XA_RESULT_PARAMETER_INVALID;
}
*newidx = oldidx;
}
DEBUG_API("<-CheckAndUnfilterIndex");
return XA_RESULT_SUCCESS;
}