diff -r 71ca22bcf22a -r 5a06f39ad45b khronosfws/openmax_al/src/adaptation/xastaticcameracapsadaptation.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/adaptation/xastaticcameracapsadaptation.c	Fri Apr 16 15:29:42 2010 +0300
@@ -0,0 +1,562 @@
+/*
+* 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 <stdio.h>
+#include <string.h>
+#include <gst.h>
+#include <photography.h>
+#include "XAGlobals.h"
+#include "XAStaticCameraCapsAdaptation.h"
+#include "XAStaticCapsAdaptation.h"
+
+#define XACAMERAIMPL_DEFAULT_MAX_ZOOM 16000 /* 16x */
+#define XACAMERAIMPL_DEFAULT_MAX_ISO 1600
+#define XACAMERAIMPL_DEFAULT_MIN_ISO 200
+#define XACAMERAIMPL_DEFAULT_MAX_APERTURE 3200 /* f/32 */
+#define XACAMERAIMPL_DEFAULT_MIN_APERTURE 75   /* f/0.75 */
+
+static XAStaticCameraCapsData allCameraCaps[] =
+{
+#ifdef XA_USE_TEST_PLUGINS
+        { XA_ADAPTID_VIDEOTESTSRC, { (XAchar*)"videotestsrc", 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
+#else
+        { XA_ADAPTID_V4L2SRC, { (XAchar*)"v4l2src", 0, 0, 0, 0, 0, 0, 0, 0, 0 } }
+#endif
+};
+
+/*forward declaration*/
+XAuint32 XAStaticCameraCaps_IdxFromId(XAuint32 cameraDeviceID);
+
+/*
+ * void XAStaticCameraCaps_Init()
+ */
+void XAStaticCameraCaps_Init()
+{
+    GstElement* element=NULL;
+    GstPhotoCaps photoCaps = GST_PHOTOGRAPHY_CAPS_NONE;
+    GError* gerror=NULL;
+    guint32 i=0;
+    guint32 numDevices = sizeof(allCameraCaps)/sizeof(XAStaticCameraCapsData);
+    gboolean detected = FALSE;
+
+
+    if ( !gst_init_check( NULL, NULL, &gerror ) )
+    {
+        DEBUG_ERR("Gst Initalization failure.");
+        return;
+    }
+    for(i=0;i<numDevices;i++)
+    {
+        /*init values*/
+        allCameraCaps[i].XAcaps.orientation = XA_ORIENTATION_UNKNOWN;
+        allCameraCaps[i].XAcaps.featuresSupported = 0;
+        allCameraCaps[i].XAcaps.exposureModesSupported = 0;
+        allCameraCaps[i].XAcaps.flashModesSupported = 0;
+        allCameraCaps[i].XAcaps.focusModesSupported = 0;
+        allCameraCaps[i].XAcaps.meteringModesSupported = 0;
+        allCameraCaps[i].XAcaps.whiteBalanceModesSupported = 0;
+        allCameraCaps[i].XAcaps.maxWidth = 0;
+        allCameraCaps[i].XAcaps.maxHeight = 0;
+
+        element = gst_element_factory_make((char*)allCameraCaps[i].XAcaps.name,NULL);
+        if(element)
+        {
+            GstPad* srcPad = gst_element_get_static_pad( element, "src");
+            if (srcPad)
+            {
+                guint32 j = 0, cnt = 0, width = 0, height = 0;
+                GstCaps* srcCaps = gst_pad_get_caps( srcPad );
+
+                /* search caps for absolute maximum values */
+                if(srcCaps)
+                {
+                    cnt = gst_caps_get_size( srcCaps );
+                    for( j = 0; j < cnt; j++ )
+                    {
+                        G_CONST_RETURN GValue* value = NULL;
+                        GstStructure* capsStruct = gst_caps_get_structure( srcCaps, j );
+
+                        if(capsStruct)
+                        {
+                            value = gst_structure_get_value( capsStruct, "width" );
+                            if (GST_VALUE_HOLDS_INT_RANGE(value))
+                            {
+                                detected = TRUE;
+                                width = gst_value_get_int_range_max( value );
+                                if(width > allCameraCaps[i].XAcaps.maxWidth)
+                                {
+                                    allCameraCaps[i].XAcaps.maxWidth = width;
+                                }
+                            }
+
+                            value = gst_structure_get_value( capsStruct, "height" );
+                            if (GST_VALUE_HOLDS_INT_RANGE(value))
+                            {
+                                detected = TRUE;
+                                height = gst_value_get_int_range_max( value );
+                                if(height > allCameraCaps[i].XAcaps.maxHeight)
+                                {
+                                    allCameraCaps[i].XAcaps.maxHeight = height;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            if(!detected)
+            {
+                DEBUG_ERR("Warn: could not get maxWidth and maxHeight from GST!!");
+                allCameraCaps[i].XAcaps.maxWidth = 0x7FFFFFFF;
+                allCameraCaps[i].XAcaps.maxHeight =  0x7FFFFFFF;
+            }
+
+            if(GST_IS_PHOTOGRAPHY(element))
+            {
+                photoCaps = gst_photography_get_capabilities(GST_PHOTOGRAPHY(element));
+                if( photoCaps & GST_PHOTOGRAPHY_CAPS_FLASH )
+                {
+                    allCameraCaps[i].XAcaps.featuresSupported |= XA_CAMERACAP_FLASH;
+                    allCameraCaps[i].XAcaps.flashModesSupported = XA_CAMERA_FLASHMODE_OFF |
+                                                       XA_CAMERA_FLASHMODE_ON |
+                                                       XA_CAMERA_FLASHMODE_AUTO |
+                                                       XA_CAMERA_FLASHMODE_REDEYEREDUCTION |
+                                                       XA_CAMERA_FLASHMODE_FILLIN;
+                }
+                if( photoCaps & GST_PHOTOGRAPHY_CAPS_FOCUS )
+                {
+                    allCameraCaps[i].XAcaps.featuresSupported |= XA_CAMERACAP_AUTOFOCUS;
+                    allCameraCaps[i].XAcaps.focusModesSupported = XA_CAMERA_FOCUSMODE_AUTO;
+                }
+                if( photoCaps & GST_PHOTOGRAPHY_CAPS_EXPOSURE )
+                {
+                    allCameraCaps[i].XAcaps.featuresSupported |= XA_CAMERACAP_MANUALEXPOSURE;
+                    allCameraCaps[i].XAcaps.exposureModesSupported = XA_CAMERA_EXPOSUREMODE_AUTO |
+                                                          XA_CAMERA_EXPOSUREMODE_PORTRAIT |
+                                                          XA_CAMERA_EXPOSUREMODE_SPORTS |
+                                                          XA_CAMERA_EXPOSUREMODE_NIGHT;
+                }
+
+                if( photoCaps & GST_PHOTOGRAPHY_CAPS_ISO_SPEED )
+                {
+                    allCameraCaps[i].XAcaps.featuresSupported |= XA_CAMERACAP_MANUALISOSENSITIVITY;
+                }
+                if( photoCaps & GST_PHOTOGRAPHY_CAPS_APERTURE )
+                {
+                    allCameraCaps[i].XAcaps.featuresSupported |= XA_CAMERACAP_MANUALAPERTURE;
+                }
+                if( photoCaps & GST_PHOTOGRAPHY_CAPS_WB_MODE )
+                {
+                    allCameraCaps[i].XAcaps.featuresSupported |= XA_CAMERACAP_AUTOWHITEBALANCE;
+                    allCameraCaps[i].XAcaps.whiteBalanceModesSupported = XA_CAMERA_WHITEBALANCEMODE_AUTO |
+                                                              XA_CAMERA_WHITEBALANCEMODE_SUNLIGHT |
+                                                              XA_CAMERA_WHITEBALANCEMODE_CLOUDY |
+                                                              XA_CAMERA_WHITEBALANCEMODE_TUNGSTEN |
+                                                              XA_CAMERA_WHITEBALANCEMODE_FLUORESCENT |
+                                                              XA_CAMERA_WHITEBALANCEMODE_SUNSET;
+                }
+                if( photoCaps & GST_PHOTOGRAPHY_CAPS_ZOOM )
+                {
+                    allCameraCaps[i].XAcaps.featuresSupported |= XA_CAMERACAP_DIGITALZOOM;
+                }
+            }
+        }
+    }
+}
+
+/*
+ * XAresult XAStaticCameraCaps_GetCameraCapabilities(
+ *                       XAuint32* pIndex,
+ *                       XAuint32* pCameraDeviceID,
+ *                       XACameraDescriptor* pDescriptor)
+ *
+ */
+XAresult XAStaticCameraCaps_GetCameraCapabilities(
+                        XAuint32* pIndex,
+                        XAuint32* pCameraDeviceID,
+                        XACameraDescriptor* pDescriptor)
+{
+    guint32 idx = 0;
+    guint32 numDevices = sizeof(allCameraCaps)/sizeof(XAStaticCameraCapsData);
+
+    if(!pDescriptor)
+    {
+        if(pIndex) /* query number of devices */
+        {
+            *pIndex = numDevices;
+            DEBUG_API("<-XAStaticCameraCaps_GetCameraCapabilities");
+            return XA_RESULT_SUCCESS;
+        }
+        else
+        {
+            DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+            DEBUG_API("<-XAStaticCameraCaps_GetCameraCapabilities");
+            return XA_RESULT_PARAMETER_INVALID;
+        }
+    }
+
+    if( !pIndex && pCameraDeviceID )
+    {
+        /* get index from ID */
+        idx = XAStaticCameraCaps_IdxFromId(*pCameraDeviceID);
+    }
+    else if( pIndex && pCameraDeviceID )
+    {
+        idx = *pIndex;
+    }
+    else
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAStaticCameraCaps_GetCameraCapabilities");
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+
+    if( idx >= numDevices )
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAStaticCameraCaps_GetCameraCapabilities");
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+    else
+    {
+        /*fill capabilities*/
+        memcpy(pDescriptor, &allCameraCaps[idx].XAcaps, sizeof(XACameraDescriptor) );
+        *pCameraDeviceID = allCameraCaps[idx].deviceID;
+    }
+
+    DEBUG_API("<-XAStaticCameraCaps_GetCameraCapabilities");
+    return XA_RESULT_SUCCESS;
+}
+
+/*
+ * XAresult XAStaticCameraCaps_QueryFocusRegionPatterns(
+ *                       XAuint32 cameraDeviceID,
+ *                       XAuint32* pPatternID,
+ *                       XAuint32* pFocusPattern,
+ *                       XAuint32* pCustomPoints1,
+ *                       XAuint32* pCustomPoints2)
+ */
+XAresult XAStaticCameraCaps_QueryFocusRegionPatterns(
+                        XAuint32 cameraDeviceID,
+                        XAuint32* pPatternID,
+                        XAuint32* pFocusPattern,
+                        XAuint32* pCustomPoints1,
+                        XAuint32* pCustomPoints2)
+{
+    DEBUG_API("->XAStaticCameraCaps_QueryFocusRegionPatterns");
+    if( !pFocusPattern )
+    {   /* return number of focus patterns */
+        if(!pPatternID)
+        {
+            DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+            DEBUG_API("<-XAStaticCameraCaps_QueryFocusRegionPatterns");
+            return XA_RESULT_PARAMETER_INVALID;
+        }
+        /* no support in GST */
+        DEBUG_INFO("No support in gst");
+        *pPatternID = 0;
+    }
+    else
+    {
+        if( !(pFocusPattern&&pCustomPoints1&&pCustomPoints2) )
+        {
+            DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+            DEBUG_API("<-XAStaticCameraCaps_QueryFocusRegionPatterns");
+            return XA_RESULT_PARAMETER_INVALID;
+        }
+        DEBUG_INFO("No support in gst");
+        *pFocusPattern = 0;
+        *pCustomPoints1 = 0;
+        *pCustomPoints2 = 0;
+        /*no focus patterns, index always out of range*/
+        DEBUG_API("<-XAStaticCameraCaps_QueryFocusRegionPatterns");
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+
+    DEBUG_API("<-XAStaticCameraCaps_QueryFocusRegionPatterns");
+    return XA_RESULT_SUCCESS;
+}
+
+/*
+ * XAresult XAStaticCameraCaps_GetSupportedAutoLocks(
+ *                       XAuint32 cameraDeviceID,
+ *                       XAuint32* pNumCombinations,
+ *                       XAuint32** ppLocks)
+ */
+XAresult XAStaticCameraCaps_GetSupportedAutoLocks(
+                        XAuint32 cameraDeviceID,
+                        XAuint32* pNumCombinations,
+                        XAuint32** ppLocks)
+{
+    DEBUG_API("->XAStaticCameraCaps_GetSupportedAutoLocks");
+    /* No support in gst.
+     * Spec: "If no settings are supported,
+     *        this method returns XA_RESULT_FEATURE_UNSUPPORTED."
+     **/
+    DEBUG_INFO("No support in gst");
+    if(pNumCombinations)
+    {
+        *pNumCombinations = 0;
+    }
+    DEBUG_API("<-XAStaticCameraCaps_GetSupportedAutoLocks");
+    return XA_RESULT_FEATURE_UNSUPPORTED;
+}
+
+/*
+ * XAresult XAStaticCameraCaps_GetSupportedFocusManualSettings(
+ *                       XAuint32 cameraDeviceID,
+ *                       XAboolean macroEnabled,
+ *                       XAmillimeter* pMinValue,
+ *                       XAmillimeter* pMaxValue,
+ *                       XAuint32* pNumSettings,
+ *                       XAmillimeter** ppSettings)
+ */
+XAresult XAStaticCameraCaps_GetSupportedFocusManualSettings(
+                        XAuint32 cameraDeviceID,
+                        XAboolean macroEnabled,
+                        XAmillimeter* pMinValue,
+                        XAmillimeter* pMaxValue,
+                        XAuint32* pNumSettings,
+                        XAmillimeter** ppSettings)
+{
+    DEBUG_API("->XAStaticCameraCaps_GetSupportedFocusManualSettings");
+    /* No support in gst.
+     * Spec: "If no settings are supported,
+     *        this method returns XA_RESULT_FEATURE_UNSUPPORTED."
+     **/
+    DEBUG_INFO("No support in gst");
+    if(pNumSettings)
+    {
+        *pNumSettings = 0;
+    }
+    DEBUG_API("<-XAStaticCameraCaps_GetSupportedFocusManualSettings");
+    return XA_RESULT_FEATURE_UNSUPPORTED;
+}
+
+/*
+ * XAresult XAStaticCameraCaps_GetSupportedISOSensitivitySettings(
+ *                       XAuint32 cameraDeviceID,
+ *                       XAuint32* pMinValue,
+ *                       XAuint32* pMaxValue,
+ *                       XAuint32* pNumSettings,
+ *                       XAuint32** ppSettings)
+ */
+XAresult XAStaticCameraCaps_GetSupportedISOSensitivitySettings(
+                        XAuint32 cameraDeviceID,
+                        XAuint32* pMinValue,
+                        XAuint32* pMaxValue,
+                        XAuint32* pNumSettings,
+                        XAuint32** ppSettings)
+{
+    DEBUG_API("->XAStaticCameraCaps_GetSupportedISOSensitivitySettings");
+    if( !pNumSettings )
+    {
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+    if( !ppSettings )
+    {
+        /* no items in ppSettings array*/
+        *pNumSettings = 0;
+    }
+    else
+    {
+        if( !(pMinValue && pMaxValue) )
+        {
+            DEBUG_API("<-XAStaticCameraCaps_GetSupportedISOSensitivitySettings");
+            return XA_RESULT_PARAMETER_INVALID;
+        }
+        /* continuous range */
+        *pNumSettings = 0;
+        /* NOTE: no way to query actual values from gstreamer, use hardcoded default values */
+        *pMinValue = XACAMERAIMPL_DEFAULT_MIN_ISO;
+        *pMaxValue = XACAMERAIMPL_DEFAULT_MAX_ISO;
+    }
+    DEBUG_API("<-XAStaticCameraCaps_GetSupportedISOSensitivitySettings");
+    return XA_RESULT_SUCCESS;
+}
+
+/*
+ * XAresult XAStaticCameraCaps_GetSupportedApertureManualSettings(
+ *                       XAuint32 cameraDeviceID,
+ *                       XAuint32* pMinValue,
+ *                       XAuint32* pMaxValue,
+ *                       XAuint32* pNumSettings,
+ *                       XAuint32** ppSettings)
+ */
+XAresult XAStaticCameraCaps_GetSupportedApertureManualSettings(
+                        XAuint32 cameraDeviceID,
+                        XAuint32* pMinValue,
+                        XAuint32* pMaxValue,
+                        XAuint32* pNumSettings,
+                        XAuint32** ppSettings)
+{
+    DEBUG_API("->XAStaticCameraCaps_GetSupportedApertureManualSettings");
+    if( !pNumSettings )
+    {
+        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+        DEBUG_API("<-XAStaticCameraCaps_GetSupportedApertureManualSettings");
+        return XA_RESULT_PARAMETER_INVALID;
+    }
+    if( !ppSettings )
+    {
+        /* no items in ppSettings array*/
+        *pNumSettings = 0;
+    }
+    else
+    {
+        /* continuous range */
+        *pNumSettings = 0;
+        /* NOTE: no way to query actual values from gstreamer, use hardcoded default values */
+        *pMinValue = XACAMERAIMPL_DEFAULT_MIN_APERTURE;
+        *pMaxValue = XACAMERAIMPL_DEFAULT_MAX_APERTURE;
+    }
+    DEBUG_API("<-XAStaticCameraCaps_GetSupportedApertureManualSettings");
+    return XA_RESULT_SUCCESS;
+}
+
+/*
+ * XAresult XAStaticCameraCaps_GetSupportedShutterSpeedManualSettings(
+ *                        XAuint32 cameraDeviceID,
+ *                       XAmicrosecond* pMinValue,
+ *                       XAmicrosecond* pMaxValue,
+ *                       XAuint32* pNumSettings,
+ *                       XAmicrosecond** ppSettings)
+ */
+XAresult XAStaticCameraCaps_GetSupportedShutterSpeedManualSettings(
+                        XAuint32 cameraDeviceID,
+                        XAmicrosecond* pMinValue,
+                        XAmicrosecond* pMaxValue,
+                        XAuint32* pNumSettings,
+                        XAmicrosecond** ppSettings)
+{
+    DEBUG_API("->XAStaticCameraCaps_GetSupportedShutterSpeedManualSettings");
+    /* No support in gst.
+     * Spec: "If no settings are supported,
+     *        this method returns XA_RESULT_FEATURE_UNSUPPORTED."
+     **/
+    DEBUG_INFO("No support in gst");
+    if(pNumSettings)
+    {
+        *pNumSettings = 0;
+    }
+    DEBUG_API("<-XAStaticCameraCaps_GetSupportedShutterSpeedManualSettings");
+    return XA_RESULT_FEATURE_UNSUPPORTED;
+}
+
+/*
+ * XAresult XAStaticCameraCaps_GetSupportedWhiteBalanceManualSettings(
+ *                       XAuint32 cameraDeviceID,
+ *                       XAuint32* pMinValue,
+ *                       XAuint32* pMaxValue,
+ *                       XAuint32* pNumSettings,
+ *                       XAuint32** ppSettings)
+ */
+XAresult XAStaticCameraCaps_GetSupportedWhiteBalanceManualSettings(
+                        XAuint32 cameraDeviceID,
+                        XAuint32* pMinValue,
+                        XAuint32* pMaxValue,
+                        XAuint32* pNumSettings,
+                        XAuint32** ppSettings)
+{
+    DEBUG_API("->XAStaticCameraCaps_GetSupportedWhiteBalanceManualSettings");
+    /* No support in gst.
+     * Spec: "If no settings are supported,
+     *        this method returns XA_RESULT_FEATURE_UNSUPPORTED."
+     **/
+    DEBUG_INFO("No support in gst");
+    if(pNumSettings)
+    {
+        *pNumSettings = 0;
+    }
+    DEBUG_API("<-XAStaticCameraCaps_GetSupportedWhiteBalanceManualSettings");
+    return XA_RESULT_FEATURE_UNSUPPORTED;
+}
+
+/*
+ * XAresult XAStaticCameraCaps_GetSupportedZoomSettings(
+ *                       XAuint32 cameraDeviceID,
+ *                       XAboolean digitalEnabled,
+ *                       XAboolean macroEnabled,
+ *                       XApermille* pMaxValue,
+ *                       XAuint32* pNumSettings,
+ *                       XApermille** ppSettings,
+ *                       XAboolean* pSpeedSupported)
+ */
+XAresult XAStaticCameraCaps_GetSupportedZoomSettings(
+                        XAuint32 cameraDeviceID,
+                        XAboolean digitalEnabled,
+                        XAboolean macroEnabled,
+                        XApermille* pMaxValue,
+                        XAuint32* pNumSettings,
+                        XApermille** ppSettings,
+                        XAboolean* pSpeedSupported)
+{
+    DEBUG_API("->XAStaticCameraCaps_GetSupportedZoomSettings");
+    if( !ppSettings )
+    {
+        if( !pNumSettings )
+        {
+            DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+            DEBUG_API("<-XAStaticCameraCaps_GetSupportedZoomSettings");
+            return XA_RESULT_PARAMETER_INVALID;
+        }
+        *pNumSettings = 0;
+    }
+    else
+    {
+        if( !(pMaxValue && pSpeedSupported) )
+        {
+            DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+            DEBUG_API("<-XAStaticCameraCaps_GetSupportedZoomSettings");
+            return XA_RESULT_PARAMETER_INVALID;
+        }
+        /*NOTE: no way to query actual max value*/
+        *pMaxValue = XACAMERAIMPL_DEFAULT_MAX_ZOOM;
+        /*no gst support for speed settings*/
+        *pSpeedSupported = XA_BOOLEAN_FALSE;
+        *pNumSettings = 0;
+    }
+    DEBUG_API("<-XAStaticCameraCaps_GetSupportedZoomSettings");
+    return XA_RESULT_SUCCESS;
+}
+
+/*
+ * XAuint32 XAStaticCameraCaps_IdxFromId(XAuint32 cameraDeviceID)
+ */
+XAuint32 XAStaticCameraCaps_IdxFromId(XAuint32 cameraDeviceID)
+{
+    XAuint32 devId = 0;
+    XAuint32 idx = 0;
+    guint32 numDevices = sizeof(allCameraCaps)/sizeof(XAStaticCameraCapsData);
+
+    if(cameraDeviceID == XA_DEFAULTDEVICEID_CAMERA)
+    {
+        devId = XACAMERAIMPL_DEFAULT_DEVICE;
+    }
+    else
+    {
+        devId = cameraDeviceID;
+    }
+
+    /* query capas with id -> find index*/
+    for(idx=0; idx<numDevices; idx++)
+    {
+        if( devId==allCameraCaps[idx].deviceID )
+            break;
+    }
+    return idx;
+}