/*

* 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 <string.h>

#include <gst/gst.h>

#include "xaadaptationgst.h"

#include "xamediarecorderadaptctx.h"

#include "xametadataadaptation.h"

/* forward declarations of internal methods */

XAMetadataAdaptVars* XAMetadataAdapt_GetMetadataVars(XAAdaptationGstCtx *bCtx);

GstStructure* XAMetadataAdapt_GetChildStructure(XAMetadataAdaptVars* mdv, XAuint32 index);

gboolean XAMetadataAdapt_CountTags(GQuark gkey, const GValue *gvalue, gpointer counter);

void XAMetadataAdapt_ParseTag(const GstTagList* list, const gchar* tag, gpointer listptr);

gboolean XAMetadataAdapt_ParseItem(GQuark field_id, const GValue * value, gpointer listptr);

gboolean XAMetadataAdapt_GstTagCb( GstBus *bus, GstMessage *message, gpointer data );

/*NOTE: no way to query these dynamically?*/

/*supported keys for metadata insertion*/

static char* xaMetadataAdaptSupportedKeys[] = {

    KHRONOS_TITLE,

    KHRONOS_ALBUM,

    KHRONOS_TRACK_NUMBER,

    KHRONOS_ARTIST,

    KHRONOS_GENRE,

    KHRONOS_COMMENT,

    KHRONOS_COPYRIGHT,

    GST_TAG_TITLE,

    GST_TAG_TITLE_SORTNAME,

    GST_TAG_ARTIST,

    GST_TAG_ARTIST_SORTNAME,

    GST_TAG_ALBUM,

    GST_TAG_ALBUM_SORTNAME,

    GST_TAG_COMPOSER,

    GST_TAG_DATE,

    GST_TAG_GENRE,

    GST_TAG_COMMENT,

    GST_TAG_EXTENDED_COMMENT,

    GST_TAG_TRACK_NUMBER,

    GST_TAG_TRACK_COUNT,

    GST_TAG_ALBUM_VOLUME_NUMBER,

    GST_TAG_ALBUM_VOLUME_COUNT,

    GST_TAG_LOCATION,

    GST_TAG_DESCRIPTION,

    GST_TAG_VERSION,

    GST_TAG_ISRC,

    GST_TAG_ORGANIZATION,

    GST_TAG_COPYRIGHT,

    GST_TAG_COPYRIGHT_URI,

    GST_TAG_CONTACT,

    GST_TAG_LICENSE,

    GST_TAG_LICENSE_URI,

    GST_TAG_PERFORMER,

    NULL

};

/******************************************************************************

 * COMMONS

 ******************************************************************************/

/* const char* XAMetadataAdapt_ParseKhronosKey(const char* pKKey)

 * Translates Khronos key string to adaptation-specific key string

 * @return Translated key string

 */

const XAchar* XAMetadataAdapt_ParseKhronosKey(const XAchar* pKKey)

{

    const XAchar* newKey;

    DEBUG_API_A1("->XAMetadataAdapt_ParseKhronosKey: \"%s\"", (char*)pKKey);

    if( strcmp((char*)pKKey,KHRONOS_TITLE) ==0 ) newKey = (XAchar*)GST_TAG_TITLE;

    else if( strcmp((char*)pKKey,KHRONOS_ALBUM) ==0 ) newKey = (XAchar*)GST_TAG_ALBUM;

    else if( strcmp((char*)pKKey,KHRONOS_TRACK_NUMBER) ==0 ) newKey = (XAchar*)GST_TAG_TRACK_NUMBER;

    else if( strcmp((char*)pKKey,KHRONOS_ARTIST) ==0 ) newKey = (XAchar*)GST_TAG_ARTIST;

    else if( strcmp((char*)pKKey,KHRONOS_GENRE) ==0 ) newKey = (XAchar*)GST_TAG_GENRE;

    else if( strcmp((char*)pKKey,KHRONOS_COMMENT) ==0 ) newKey = (XAchar*)GST_TAG_COMMENT;

    else if( strcmp((char*)pKKey,KHRONOS_COPYRIGHT) ==0 ) newKey = (XAchar*)GST_TAG_COPYRIGHT;

    else newKey = pKKey;

/* No Gst keys for following:

    else if( strcmp(pKKey,KHRONOS_YEAR) ==0 ) newKey = ;

    else if( strcmp(pKKey,KHRONOS_ARTIST_URL) ==0 ) newKey = ;

    else if( strcmp(pKKey,KHRONOS_CONTENT_URL) ==0 ) newKey = ;

    else if( strcmp(pKKey,KHRONOS_RATING) ==0 ) newKey = ;

    else if( strcmp(pKKey,KHRONOS_ALBUM_ART) ==0 ) newKey = ;

 */

    DEBUG_API_A1("<-XAMetadataAdapt_ParseKhronosKey: => \"%s\"", (char*)newKey);

    return newKey;

}

/* XAresult XAMetadataAdapt_PreInit(XAAdaptationGstCtx *bCtx)

 * Initialize values needed before preroll

 * @return XAresult ret - Success value

 */

XAresult XAMetadataAdapt_PreInit(XAAdaptationGstCtx *bCtx)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAMetadataAdaptVars* mdv;

    DEBUG_API("->XAMetadataAdapt_PreInit");

    if ( bCtx->baseObj.ctxId == XAMediaRecorderAdaptation )

    {

        mdv = (XAMetadataAdaptVars*) calloc(1, sizeof(XAMetadataAdaptVars));

        mdv->currentchild = &(mdv->generaltags);

        mdv->traversemode=XA_METADATATRAVERSALMODE_NODE;

        ((XAMediaRecorderAdaptationCtx*)bCtx)->metadatavars = mdv;

    }

    else

    {

        DEBUG_ERR("Unsupported metadata context!!");

        ret = XA_RESULT_FEATURE_UNSUPPORTED;

    }

    if(ret == XA_RESULT_SUCCESS)

    {

        if(bCtx->bus)

        {

            g_signal_connect(bCtx->bus, "message::tag", G_CALLBACK(XAMetadataAdapt_GstTagCb), bCtx );

        }

        else

        {

            DEBUG_ERR("No bus in context!!");

            ret = XA_RESULT_PRECONDITIONS_VIOLATED;

        }

    }

    DEBUG_API_A1("<-XAMetadataAdapt_PreInit (%d)", (int)ret);

    return ret;

}

/* XAresult XAMetadataAdapt_PostInit(XAAdaptationGstCtx *bCtx)

 * Initialize values after preroll

 * @return XAresult ret - Success value

 */

XAresult XAMetadataAdapt_PostInit(XAAdaptationGstCtx *bCtx)

{

    XAresult ret = XA_RESULT_SUCCESS;

    DEBUG_API("->XAMetadataAdapt_PostInit");

    DEBUG_API_A1("<-XAMetadataAdapt_PostInit (%d)", (int)ret);

    return ret;

}

/*

 * void XAMetadataAdapt_FreeImplTagList(XAMetadataImplTagList *list, XAboolean freeItems)

 * deallocate elements inside taglist

 */

void XAMetadataAdapt_FreeImplTagList(XAMetadataImplTagList *list, XAboolean freeItems)

{

    XAuint16 i;

    DEBUG_API("->XAMetadataExtractionItfAdapt_FreeTagList");

    if(list->mdeKeys)

    {

        for(i=0;i<list->itemcount;i++)

        {

            if(list->mdeKeys[i])

            {

                if(freeItems)

                    free(list->mdeKeys[i]);

                list->mdeKeys[i]=NULL;

            }

        }

        free(list->mdeKeys);

        list->mdeKeys = NULL;

    }

    if(list->mdeValues)

    {

        for(i=0;i<list->itemcount;i++)

        {

            if(list->mdeValues[i])

            {

                if(freeItems)

                    free(list->mdeValues[i]);

                list->mdeValues[i]=NULL;

            }

        }

        free(list->mdeValues);

        list->mdeValues = NULL;

    }

    list->itemcount = 0;

    DEBUG_API("<-XAMetadataExtractionItfAdapt_FreeTagList");

}

/*

 * void XAMetadataAdapt_FreeVars(XAMetadataAdaptVars *vars)

 * deallocate XAMetadataAdaptVars

 */

void XAMetadataAdapt_FreeVars(XAMetadataAdaptVars *vars)

{

    DEBUG_API("->XAMetadataAdapt_FreeVars");

    if(vars)

    {

        if( vars->generaltags )

        {

            gst_tag_list_free(vars->generaltags);

        }

        if( vars->audiotags )

        {

            gst_structure_set_parent_refcount(vars->audiotags,NULL);

            gst_structure_free(vars->audiotags);

        }

        if( vars->videotags )

        {

            gst_structure_set_parent_refcount(vars->videotags,NULL);

            gst_structure_free(vars->videotags);

        }

        free(vars);

    }

    DEBUG_API("<-XAMetadataAdapt_FreeVars");

}

/******************************************************************************

 * EXTRACTION

 ******************************************************************************/

/*

 * XAresult XAMetadataExtractionItfAdapt_FillTagList()

 * @param tagList - contains pointer to tag list to be updated

 * @return XAresult ret - Success value

 */

XAresult XAMetadataExtractionItfAdapt_FillTagList(XAAdaptationGstCtx *bCtx,

                                                  XAMetadataImplTagList* tagList)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAMetadataAdaptVars* mdv;

    XAuint32 newcount = 0;

    DEBUG_API("->XAMetadataExtractionItfAdapt_FillTagList");

    mdv = XAMetadataAdapt_GetMetadataVars(bCtx);

    if( mdv )

    {

        XAMetadataAdapt_FreeImplTagList(tagList, XA_BOOLEAN_TRUE);

        /* get number of tags and allocate memory for them */

        if(mdv->traversemode==XA_METADATATRAVERSALMODE_ALL)

        {

            if(mdv->generaltags)

                gst_structure_foreach(mdv->generaltags, XAMetadataAdapt_CountTags, &newcount);

            if(mdv->audiotags)

                gst_structure_foreach(mdv->audiotags, XAMetadataAdapt_CountTags, &newcount);

            if(mdv->videotags)

                gst_structure_foreach(mdv->videotags, XAMetadataAdapt_CountTags, &newcount);

        }

        else

        {

            if(mdv->currentchild && *(mdv->currentchild))

                gst_structure_foreach(*(mdv->currentchild), XAMetadataAdapt_CountTags, &newcount);

        }

        DEBUG_INFO_A1("tag count = %d",(int)newcount)

        tagList->mdeKeys = (XAMetadataInfo**)calloc(newcount,sizeof(XAMetadataInfo*));

        tagList->mdeValues = (XAMetadataInfo**)calloc(newcount,sizeof(XAMetadataInfo*));

        /* fill in given tag list */

        tagList->itemcount = 0;

        if(mdv->traversemode==XA_METADATATRAVERSALMODE_ALL)

        {

            if(mdv->generaltags)

                gst_tag_list_foreach(mdv->generaltags, XAMetadataAdapt_ParseTag, tagList);

            if(mdv->audiotags)

                gst_structure_foreach(mdv->audiotags, XAMetadataAdapt_ParseItem, tagList);

            if(mdv->videotags)

                gst_structure_foreach(mdv->videotags, XAMetadataAdapt_ParseItem, tagList);

        }

        else

        {

            if(mdv->currentchild && *(mdv->currentchild))

            {

                if(GST_IS_TAG_LIST(*(mdv->currentchild)))

                {

                    gst_tag_list_foreach(*(mdv->currentchild), XAMetadataAdapt_ParseTag, tagList);

                }

                else

                {

                    gst_structure_foreach(*(mdv->currentchild), XAMetadataAdapt_ParseItem, tagList);

                }

            }

        }

    }

    else

    {

        DEBUG_ERR("Metadata variables not found!!");

        ret = XA_RESULT_PARAMETER_INVALID;

    }

    DEBUG_API_A1("<-XAMetadataExtractionItfAdapt_FillTagList (%d)", (int)ret);

    return ret;

}

/******************************************************************************

 * TRAVERSAL

 *****************************************************************************/

/*

 * XAresult XAMetadataTraversalItfAdapt_SetMode(XAAdaptationGstCtx *bCtx, XAuint32 mode)

 */

XAresult XAMetadataTraversalItfAdapt_SetMode(XAAdaptationGstCtx *bCtx, XAuint32 mode)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAMetadataAdaptVars* mdv=NULL;

    XAAdaptEvent event = {XA_METADATAEVENTS, XA_ADAPT_MDE_TAGS_AVAILABLE, 0, NULL };

    DEBUG_API("->XAMetadataTraversalItfAdapt_SetMode");

    mdv = XAMetadataAdapt_GetMetadataVars(bCtx);

    if( mdv )

    {

        mdv->traversemode = mode;

        /* inform extractor to update tag list */

        XAAdaptationBase_SendAdaptEvents(&bCtx->baseObj, &event );

        if(mdv->traversemode==XA_METADATATRAVERSALMODE_ALL)

        {

            mdv->nodedepth = 0;

            mdv->currentchild = &(mdv->generaltags);

        }

    }

    else

    {

        DEBUG_ERR("Metadata variables not found!!");

        ret = XA_RESULT_PARAMETER_INVALID;

    }

    DEBUG_API("<-XAMetadataTraversalItfAdapt_SetMode");

    return ret;

}

/*

 * XAresult XAMetadataTraversalItfAdapt_GetChildCount(XAAdaptationGstCtx *bCtx, XAuint32 *pCount)

 */

XAresult XAMetadataTraversalItfAdapt_GetChildCount(XAAdaptationGstCtx *bCtx, XAuint32 *pCount)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAMetadataAdaptVars* mdv=NULL;

    DEBUG_API("->XAMetadataTraversalItfAdapt_GetChildCount");

    mdv = XAMetadataAdapt_GetMetadataVars(bCtx);

    if( mdv )

    {

        /* only depth of 1 is supported */

        if( mdv->nodedepth == 0 )

        {

            *pCount=mdv->childcount;

        }

        else

        {

            *pCount=0;

        }

    }

    else

    {

        DEBUG_ERR("Metadata variables not found!!");

        ret = XA_RESULT_PARAMETER_INVALID;

        *pCount=0;

    }

    DEBUG_API_A2("<-XAMetadataTraversalItfAdapt_GetChildCount(%d) count=%d", (int)ret, (int)*pCount);

    return ret;

}

/*

 * XAresult XAMetadataTraversalItfAdapt_GetChildMIMETypeSize(XAAdaptationGstCtx *bCtx,

 *                                                         XAuint32 index,

 *                                                         XAuint32 *pSize)

 */

XAresult XAMetadataTraversalItfAdapt_GetChildMIMETypeSize(XAAdaptationGstCtx *bCtx,

                                                          XAuint32 index,

                                                          XAuint32 *pSize)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAMetadataAdaptVars* mdv=NULL;

    DEBUG_API("->XAMetadataTraversalItfAdapt_GetChildMIMETypeSize");

    mdv = XAMetadataAdapt_GetMetadataVars(bCtx);

    if( mdv )

    {

        GstStructure* child = XAMetadataAdapt_GetChildStructure(mdv,index);

        if(child)

        {

            *pSize = strlen(gst_structure_get_name(child));

        }

    }

    else

    {

        DEBUG_ERR("Metadata variables not found!!");

        ret = XA_RESULT_PARAMETER_INVALID;

        *pSize=0;

    }

    DEBUG_API("<-XAMetadataTraversalItfAdapt_GetChildMIMETypeSize");

    return ret;

}

/*

 * XAresult XAMetadataTraversalItfAdapt_GetChildInfo(XAAdaptationGstCtx *bCtx,

 *                                                  XAuint32 index,

 *                                                 XAint32 *pNodeID,

 *                                                 XAuint32 *pType,

 *                                                 XAuint32 size,

 *                                                 XAchar *pMimeType)

 */

XAresult XAMetadataTraversalItfAdapt_GetChildInfo(XAAdaptationGstCtx *bCtx,

                                                  XAuint32 index,

                                                  XAint32 *pNodeID,

                                                  XAuint32 *pType,

                                                  XAuint32 size,

                                                  XAchar *pMimeType)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAMetadataAdaptVars* mdv=NULL;

    const gchar* mime;

    GstStructure* child;

    DEBUG_API("->XAMetadataTraversalItfAdapt_GetChildInfo");

    mdv = XAMetadataAdapt_GetMetadataVars(bCtx);

    if( mdv )

    {

        child = XAMetadataAdapt_GetChildStructure(mdv,index);

        if(child)

        {

            *pNodeID = (XAint32)child;

            mime = gst_structure_get_name(child);

            if(strncmp(mime,"audio",5)==0)

            {

                *pType = XA_NODETYPE_AUDIO;

            }

            if(strncmp(mime,"video",5)==0)

            {

                *pType = XA_NODETYPE_VIDEO;

            }

            if(strncmp(mime,"image",5)==0)

            {

                *pType = XA_NODETYPE_IMAGE;

            }

            else

            {

                *pType = XA_NODETYPE_UNSPECIFIED;

            }

            strncpy((char*)pMimeType,mime,size);

        }

    }

    else

    {

        DEBUG_ERR("Metadata variables not found!!");

        ret = XA_RESULT_PARAMETER_INVALID;

    }

    DEBUG_API("<-XAMetadataTraversalItfAdapt_GetChildInfo");

    return ret;

}

/*

 * XAresult XAMetadataTraversalItfAdapt_SetActiveNode(XAAdaptationGstCtx *bCtx,

 *                                                  XAuint32 index)

 */

XAresult XAMetadataTraversalItfAdapt_SetActiveNode(XAAdaptationGstCtx *bCtx,

                                                   XAuint32 index)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAMetadataAdaptVars* mdv=NULL;

    GstStructure* child;

    DEBUG_API("->XAMetadataTraversalItfAdapt_SetActiveNode");

    mdv = XAMetadataAdapt_GetMetadataVars(bCtx);

    if( mdv )

    {

        child = XAMetadataAdapt_GetChildStructure(mdv,index);

        if(child)

        {

            mdv->currentchild = &child;

            if(index==XA_NODE_PARENT) mdv->nodedepth--;

            else mdv->nodedepth++;

        }

    }

    else

    {

        DEBUG_ERR("Metadata variables not found!!");

        ret = XA_RESULT_PARAMETER_INVALID;

    }

    DEBUG_API("<-XAMetadataTraversalItfAdapt_SetActiveNode");

    return ret;

}

/*****************************************************************************

 * INSERTION

 *****************************************************************************/

/*

 * XAresult XAMetadataInsertionItfAdapt_CreateChildNode(XAAdaptationGstCtx *bCtx,

 *                                                   XAint32 parentNodeID,

 *                                                   XAuint32 type,

 *                                                   XAchar *mimeType,

 *                                                   XAint32 *pChildNodeID)

 */

XAresult XAMetadataInsertionItfAdapt_CreateChildNode(XAAdaptationGstCtx *bCtx,

                                                    XAint32 parentNodeID,

                                                    XAuint32 type,

                                                    XAchar *mimeType,

                                                    XAint32 *pChildNodeID)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAMetadataAdaptVars* mdv=NULL;

    XAMediaRecorderAdaptationCtx* mCtx;

    DEBUG_API("->XAMetadataInsertionItfAdapt_CreateChildNode");

    if(bCtx && bCtx->baseObj.ctxId == XAMediaRecorderAdaptation)

    {

        /* no support for more than 1 levels of childs*/

        if(parentNodeID==XA_ROOT_NODE_ID)

        {

            XAMediaType mediaType;

            mCtx = (XAMediaRecorderAdaptationCtx*)bCtx;

            /* first check sink type */

            XACommon_CheckDataSource((XADataSource*)(mCtx->xaSink),&mediaType);

            if( ((mediaType==XA_MEDIATYPE_AUDIO||mediaType==XA_MEDIATYPE_VIDEO) && type==XA_NODETYPE_IMAGE) ||

                (mediaType==XA_MEDIATYPE_IMAGE && (type==XA_NODETYPE_AUDIO || type==XA_NODETYPE_VIDEO)) )

            {

                DEBUG_ERR("Nodetype not supported!");

                ret = XA_RESULT_CONTENT_UNSUPPORTED;

                DEBUG_API_A1("<-XAMetadataInsertionItfAdapt_CreateChildNode (%d)", (int)ret);

                return ret;

            }