/*

* 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 "xametadataadaptctx.h"

#include "xamediaplayeradaptctx.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 == XAMDAdaptation ||

        bCtx->baseObj.ctxId == XAMediaPlayerAdaptation )

    {

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

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

        mdv->traversemode=XA_METADATATRAVERSALMODE_NODE;

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

    }

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

    XAMetadataAdaptVars* mdv=NULL;

    XAMediaPlayerAdaptationCtx* mCtx=NULL;

    GstPad* tmppad=NULL;

    GstCaps* tmpcaps=NULL;

    GstElement* tmpelement=NULL;

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

    DEBUG_API("->XAMetadataAdapt_PostInit");

    if( bCtx->baseObj.ctxId == XAMDAdaptation ||

        bCtx->baseObj.ctxId == XAMediaPlayerAdaptation )

    {

        mdv = XAMetadataAdapt_GetMetadataVars(bCtx);

        if( mdv )

        {

            mdv->childcount = 0;

            /* try to dig out audio and video pads from decodebin for stream info tags */

            /* NOTE: currently no good deterministic way to dig out undecoded pads

             * from decodebin's internal demuxer, this is just ugly way to try to cope

             * with most demuxers.

             */

            mCtx = ((XAMediaPlayerAdaptationCtx*)bCtx);

            if(GST_IS_BIN(mCtx->codecbin))

            {

                tmpelement=gst_bin_get_by_name(GST_BIN(mCtx->codecbin),"typefind");

                if(tmpelement)

                {

                    tmppad = gst_element_get_static_pad(GST_ELEMENT(tmpelement),"src");

                    tmpelement=NULL;

                    if(tmppad)

                    {

                        tmppad = gst_pad_get_peer(tmppad);

                        if(tmppad)

                        {

                            tmpelement = gst_pad_get_parent_element(tmppad);

                        }

                    }

                    /* now we have demuxer, if existing */

                    if(tmpelement)

                    {

                        tmppad = gst_element_get_pad( tmpelement, "audio_00");

                        if(tmppad)

                        {

                            tmpcaps = gst_pad_get_negotiated_caps( GST_PAD(tmppad) );

                            if(tmpcaps==NULL || gst_caps_is_any(tmpcaps) || gst_caps_is_empty(tmpcaps))

                            {

                                mdv->audiotags = NULL;

                                DEBUG_INFO("no usable audio properties found from pad !");

                            }

                            else

                            {

                                mdv->audiotags = gst_caps_get_structure(tmpcaps,0);

                                mdv->childcount++;

                                DEBUG_INFO_A1("found audio node: %s",gst_caps_to_string(tmpcaps));

                            }

                        }

                        tmppad = gst_element_get_pad( tmpelement, "video_00");

                        if(tmppad)

                        {

                            tmpcaps = gst_pad_get_negotiated_caps( GST_PAD(tmppad) );

                            if(tmpcaps==NULL || gst_caps_is_any(tmpcaps) || gst_caps_is_empty(tmpcaps))

                            {

                                mdv->videotags = NULL;

                                DEBUG_INFO("no usable video properties found from pad !");

                            }

                            else

                            {

                                mdv->videotags = gst_caps_get_structure(tmpcaps,0);

                                mdv->childcount++;

                                DEBUG_INFO_A1("found video node: %s",gst_caps_to_string(tmpcaps));

                            }

                        }

                    }

                }

            }

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

        }

    }

    if ( tmpelement )

    {

    	gst_object_unref( tmpelement );

    }

    if ( tmppad )

    {

    	gst_object_unref( tmppad );

    }

    if ( tmpcaps )

    {

    	gst_object_unref( tmpcaps );

    }

    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;