diff -r a36789189b53 -r 095bea5f582e khronosfws/openmax_al/src/gst_adaptation/xagstcapabilitiesmgr.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/gst_adaptation/xagstcapabilitiesmgr.c	Tue Aug 31 15:43:02 2010 +0300
@@ -0,0 +1,501 @@
+/*
+ * 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;
+    }