/*
 * 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: GST Capabilities Mgr. Here you can query the capabilities
 *               of various GST components and store it in a list.
 *
 */

#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <gst/gst.h>
#include <gobject_global.h>

#include "xagstcapabilitiesmgr.h"
#include "xaframeworkmgr.h"

static XAresult XAGSTCapabilitiesMgr_GetAudioAACEncoderCapabilities(
        XACapabilities **ppNode);
static XAresult XAGSTCapabilitiesMgr_GetAudioAMREncoderCapabilities(
        XACapabilities **ppNode);
static XAresult XAGSTCapabilitiesMgr_GetAudioPCMEncoderCapabilities(
        XACapabilities **ppNode);
static XAresult XAGSTCapabilitiesMgr_GetCapabilities_FromGstElement(
        XAAudioCodecDescriptor **entries, XAuint32 type);

/* XAresult XAGSTCapabilitiesMgr_UpdateCapabilitieList
 * Description: Update the capabilities list supported by GStreamer framework.
 */
static gboolean populate_field(GQuark field, const GValue * value,
        gpointer pfx)
    {
    gchar *field_name;
    gpointer *pfxd = (gpointer*) pfx;
    XAAudioCodecDescriptor *ctxx = (XAAudioCodecDescriptor *) pfxd;

    field_name = (gchar*) g_quark_to_string(field);

    if ((strcasecmp((const char*) field_name, "channels") == 0))
        {
        if (GST_VALUE_HOLDS_INT_RANGE(value) == TRUE)
            {
            (ctxx)->maxChannels = gst_value_get_int_range_max(value);
            }
        else
            (ctxx)->maxChannels = g_value_get_int(value);
        }
    if ((strcasecmp((const char*) field_name, "depth") == 0))
        {
        if (GST_VALUE_HOLDS_INT_RANGE(value) == TRUE)
            {
            (ctxx)->minBitsPerSample = gst_value_get_int_range_min(value);
            }
        else
            (ctxx)->minBitsPerSample = g_value_get_int(value);
        }
    if ((strcasecmp((const char*) field_name, "bitrate") == 0))
        {
        if (GST_VALUE_HOLDS_INT_RANGE(value) == TRUE)
            {
            (ctxx)->minBitRate = gst_value_get_int_range_min(value);
            (ctxx)->maxBitRate = gst_value_get_int_range_max(value);
            }
        else
            {
            (ctxx)->minBitRate = g_value_get_int(value);
            (ctxx)->maxBitRate = g_value_get_int(value);
            }
        }
    if ((strcasecmp((const char*) field_name, "width") == 0))
        {
        if (GST_VALUE_HOLDS_INT_RANGE(value) == TRUE)
            {
            (ctxx)->maxBitsPerSample = gst_value_get_int_range_max(value);
            }
        else
            (ctxx)->maxBitsPerSample = g_value_get_int(value);
        }
    if ((strcasecmp((const char*) field_name, "rate") == 0))
        {
        if (GST_VALUE_HOLDS_INT_RANGE(value) == TRUE)
            {
            (ctxx)->minSampleRate = gst_value_get_int_range_min(value) * 1000;
            (ctxx)->maxSampleRate = gst_value_get_int_range_max(value) * 1000;
            }
        else
            {
            (ctxx)->minSampleRate = g_value_get_int(value) * 1000;
            (ctxx)->maxSampleRate = g_value_get_int(value) * 1000;
            }
        }

    return TRUE;
    }

XAresult XAGSTCapabilitiesMgr_GetCapabilities_FromGstElement(
        XAAudioCodecDescriptor **entries, XAuint32 type)
    {
    int i = 0;
    GstElement *element = NULL;
    GstPad *elementpad = NULL;
    GstCaps *elementcaps = NULL;
    GstStructure *s = NULL;
    GParamSpec *elementproperty;
    GParamSpecInt *pint;
    GParamSpecEnum *penum;
    gchar *findamr = "\0";
    gpointer *myentries;


    if (type == XA_AUDIOCODEC_AAC)
        {
        element = gst_element_factory_make("nokiaaacenc", "encoderelement");
        if (element)
            {
            elementpad = gst_element_get_static_pad(element, "sink");
            if (!elementpad)
                {
                DEBUG_ERR("no pad found for AAC Encoder");
                return XA_RESULT_INTERNAL_ERROR;
                }
            elementcaps = gst_pad_get_caps(elementpad);
            s = gst_caps_get_structure(elementcaps, 0);

            myentries = (gpointer*) *entries;
            gst_structure_foreach(s, populate_field, (gpointer) myentries);

            elementproperty = g_object_class_find_property(
                    G_OBJECT_GET_CLASS (element), "bitrate");
            if (elementproperty)
                {
                pint = G_PARAM_SPEC_INT (elementproperty);
                (*entries)->minBitRate = pint->minimum;
                (*entries)->maxBitRate = pint->maximum;
                }
            elementproperty = g_object_class_find_property(
                    G_OBJECT_GET_CLASS (element), "profile");
            if (elementproperty)
                {
                penum = G_PARAM_SPEC_ENUM(elementproperty);
                (*entries)->modeSetting = penum->default_value;
                }

            (*entries)->profileSetting = XA_AUDIOPROFILE_AAC_AAC;
            (*entries)->isFreqRangeContinuous = XA_BOOLEAN_TRUE;
            (*entries)->isBitrateRangeContinuous = XA_BOOLEAN_TRUE;
            }
        else
            {
            DEBUG_ERR("failed to get the AACencoder element");
            }
        }
    else if (type == XA_AUDIOCODEC_AMR)
        {
        element = gst_element_factory_make("devsoundsrc", "encoderelement");
        if (element)
            {
            elementpad = gst_element_get_pad(element, "src");
            if (!elementpad)
                {
                DEBUG_ERR("no source pad for Devsound(amr) element");
                return XA_RESULT_INTERNAL_ERROR;
                }

            elementcaps = gst_pad_get_caps(elementpad);
            while (!(strcasecmp(findamr, "audio/amr") == 0) && i
                    < elementcaps->structs->len)
                {
                s = gst_caps_get_structure(elementcaps, i);
                findamr = (char*) gst_structure_get_name(s);
                i++;
                }

            //populating the Other Values
            myentries = (gpointer*) *entries;
            gst_structure_foreach(s, populate_field, (gpointer) myentries);

            elementproperty = g_object_class_find_property(
                    G_OBJECT_GET_CLASS (element), "speechbitrate");
            if (elementproperty)
                {
                pint = G_PARAM_SPEC_INT (elementproperty);
                (*entries)->minBitRate = pint->minimum;
                (*entries)->maxBitRate = pint->maximum;
                }

            (*entries)->profileSetting = XA_AUDIOPROFILE_AMR;
            (*entries)->modeSetting = 0;
            (*entries)->isFreqRangeContinuous = XA_BOOLEAN_TRUE;
            (*entries)->isBitrateRangeContinuous = XA_BOOLEAN_TRUE;

            }
        else
            {
            DEBUG_ERR("failed to get the Devsoundsrc(amr encoder) element");
            }
        }

    else if (type == XA_AUDIOCODEC_PCM)
        {
        element = gst_element_factory_make("wavenc", "encoderelement");
        if (element)
            {
            elementpad = gst_element_get_pad(element, "sink");
            if (!elementpad)
                {
                DEBUG_ERR("failed to get Sink pad on Wave encoder element");
                return XA_RESULT_INTERNAL_ERROR;
                }
            elementcaps = gst_pad_get_caps(elementpad);
            s = gst_caps_get_structure(elementcaps, 2);
            myentries = (gpointer*) *entries;
            gst_structure_foreach(s, populate_field, (gpointer) myentries);
            elementproperty = g_object_class_find_property(
                    G_OBJECT_GET_CLASS (element), "bitrate");
            if (elementproperty)
                {
                pint = G_PARAM_SPEC_INT (elementproperty);
                (*entries)->minBitRate = pint->minimum;
                (*entries)->maxBitRate = pint->maximum;
                }

            (*entries)->profileSetting = XA_AUDIOPROFILE_PCM;
            (*entries)->modeSetting = 0;
            (*entries)->isFreqRangeContinuous = XA_BOOLEAN_TRUE;
            (*entries)->isBitrateRangeContinuous = XA_BOOLEAN_TRUE;
            }
        else
            {
            DEBUG_ERR("failed to get the wavencoder element");
            }
        }

    if (elementcaps != NULL)
        gst_caps_unref(elementcaps);
    if (elementpad != NULL)
        gst_object_unref(elementpad);
    if (element != NULL)
        gst_object_unref(element);

    return XA_RESULT_SUCCESS;
    }
XAresult XAGSTCapabilitiesMgr_UpdateCapabilitieList(
        FrameworkMap *frameworkMap, XACapabilities **ppListHead)

    {
    XAresult res = XA_RESULT_SUCCESS;
    XACapabilities *newNode = NULL;
    FWMgrFwType fwtype = FWMgrFWUknown;
    char *uri = NULL;
    XACapabilities *lastNode;
    XACapabilities *firstNode;

    DEBUG_API("->XAGSTCapabilitiesMgr_UpdateCapabilitieList");

    if (!frameworkMap || !ppListHead)
        {
        res = XA_RESULT_PARAMETER_INVALID;
        return res;
        }

    lastNode = firstNode = *ppListHead;

    /* traverse and point to the last node in the list */
    while (lastNode && lastNode->next)
        {
        lastNode = lastNode->next;
        }

    uri = "file:///c:/test.mp4";
    fwtype = XAFrameworkMgr_GetFramework(frameworkMap, uri, FWMgrMORecorder);

    if (fwtype == FWMgrFWGST)
        {
        GError* gerror = 0;
        //initialize gstreamer
        //AL_PROFILING_BEGIN;
        if (!gst_init_check(NULL, NULL, &gerror))
            {
            DEBUG_ERR("Gst Initalization failure.");
            return XA_RESULT_INTERNAL_ERROR;
            }
        //AL_PROFILING_END_PRINT("gst_init_check");

        }

    if (fwtype == FWMgrFWGST)
        {
        /* Add codec capabilities */
        newNode = NULL;
        res = XAGSTCapabilitiesMgr_GetAudioAACEncoderCapabilities(&newNode);
        if (res != XA_RESULT_SUCCESS)
            {
            return res;
            }
        if (lastNode)
            {
            lastNode->next = newNode;
            }
        if (newNode)
            { /* if a new node is created move lastNode to the new item */
            if (!firstNode)
                firstNode = newNode;
            lastNode = newNode;
            }
        }

    uri = "file:///c:/test.amr";
    fwtype = XAFrameworkMgr_GetFramework(frameworkMap, uri, FWMgrMORecorder);

    if (fwtype == FWMgrFWGST)
        {
        newNode = NULL;
        res = XAGSTCapabilitiesMgr_GetAudioAMREncoderCapabilities(&newNode);
        if (res != XA_RESULT_SUCCESS)
            {
            return res;
            }
        if (lastNode)
            {
            lastNode->next = newNode;
            }
        if (newNode)
            { /* if a new node is created move lastNode to the new item */
            if (!firstNode)
                firstNode = newNode;
            lastNode = newNode;
            }
        }

    uri = "file:///c:/test.wav";
    fwtype = XAFrameworkMgr_GetFramework(frameworkMap, uri, FWMgrMORecorder);

    if (fwtype == FWMgrFWGST)
        {
        newNode = NULL;
        res = XAGSTCapabilitiesMgr_GetAudioPCMEncoderCapabilities(&newNode);
        if (res != XA_RESULT_SUCCESS)
            {
            return res;
            }
        if (lastNode)
            {
            lastNode->next = newNode;
            }
        if (newNode)
            { /* if a new node is created move lastNode to the new item */
            if (!firstNode)
                firstNode = newNode;
            lastNode = newNode;
            }
        }
    /* if empty list, then append first node as the head */
    if (!(*ppListHead))
        {
        *ppListHead = firstNode;
        }
    DEBUG_API("<-XAGSTCapabilitiesMgr_UpdateCapabilitieList");
    return res;
    }

XAresult XAGSTCapabilitiesMgr_GetAudioAACEncoderCapabilities(
        XACapabilities **ppNode)
    {
    XAresult res = XA_RESULT_SUCCESS;
    XACapabilities *newNode = NULL;
    XAAudioCodecDescriptor *entries = NULL;
    XAchar aacencelement[] = "nokiaaacenc";
    int strLen = 0;

    newNode = (XACapabilities *) calloc(1, sizeof(XACapabilities));
    if (!newNode)
        {
        res = XA_RESULT_MEMORY_FAILURE;
        return res;
        }

    newNode->capsType = AUD_E;
    newNode->xaid = XA_AUDIOCODEC_AAC;
    newNode->noOfEntries = 1;

    strLen = strlen((char*) aacencelement);
    newNode->adaptId = (XAchar *) calloc(strLen + 1, sizeof(XAchar));
    if (!newNode->adaptId)
        {
        res = XA_RESULT_MEMORY_FAILURE;
        XACapabilitiesMgr_DeleteCapabilitieList(&newNode);
        return res;
        }

    strncpy((char*) newNode->adaptId, (char*) aacencelement, strLen);
    newNode->adaptId[strLen] = '\0'; /*Null terminate it*/

    /* Allocate array */
    entries = (XAAudioCodecDescriptor*) calloc(1,
            sizeof(XAAudioCodecDescriptor));
    if (!entries)
        {
        res = XA_RESULT_MEMORY_FAILURE;
        XACapabilitiesMgr_DeleteCapabilitieList(&newNode);
        return res;
        }

    newNode->pEntry = (void*) entries;

    res = XAGSTCapabilitiesMgr_GetCapabilities_FromGstElement(&entries,
            newNode->xaid);

    newNode->pEntry = (void*) entries;

    *ppNode = newNode;
    return res;
    }

XAresult XAGSTCapabilitiesMgr_GetAudioAMREncoderCapabilities(
        XACapabilities **ppNode)
    {
    XAresult res = XA_RESULT_SUCCESS;
    XACapabilities *newNode = NULL;
    XAAudioCodecDescriptor *entries = NULL;

    newNode = (XACapabilities *) calloc(1, sizeof(XACapabilities));
    if (!newNode)
        {
        res = XA_RESULT_MEMORY_FAILURE;
        return res;
        }

    newNode->capsType = AUD_E;
    newNode->xaid = XA_AUDIOCODEC_AMR;
    newNode->noOfEntries = 1;

    /* Allocate array */
    entries = (XAAudioCodecDescriptor*) calloc(1,
            sizeof(XAAudioCodecDescriptor));
    if (!entries)
        {
        res = XA_RESULT_MEMORY_FAILURE;
        XACapabilitiesMgr_DeleteCapabilitieList(&newNode);
        return res;
        }

    newNode->pEntry = (void*) entries;

    XAGSTCapabilitiesMgr_GetCapabilities_FromGstElement(&entries,
            newNode->xaid);

    newNode->pEntry = (void*) entries;

    *ppNode = newNode;
    return res;
    }

XAresult XAGSTCapabilitiesMgr_GetAudioPCMEncoderCapabilities(
        XACapabilities **ppNode)
    {
    XAresult res = XA_RESULT_SUCCESS;
    XACapabilities *newNode = NULL;
    XAAudioCodecDescriptor *entries = NULL;

    newNode = (XACapabilities *) calloc(1, sizeof(XACapabilities));
    if (!newNode)
        {
        res = XA_RESULT_MEMORY_FAILURE;
        return res;
        }

    newNode->capsType = AUD_E;
    newNode->xaid = XA_AUDIOCODEC_PCM;
    newNode->noOfEntries = 1;

    /* Allocate array */
    entries = (XAAudioCodecDescriptor*) calloc(1,
            sizeof(XAAudioCodecDescriptor));
    if (!entries)
        {
        res = XA_RESULT_MEMORY_FAILURE;
        XACapabilitiesMgr_DeleteCapabilitieList(&newNode);
        return res;
        }

    newNode->pEntry = (void*) entries;

    XAGSTCapabilitiesMgr_GetCapabilities_FromGstElement(&entries,
            newNode->xaid);

    newNode->pEntry = (void*) entries;

    *ppNode = newNode;
    return res;
    }