/*

 * 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;

        }