--- /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;
+ }