1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 #include <gst.h>

    19 #include <photography.h>

    20 #include "XACameraAdaptCtx.h"

    21 #include "XACameraItfAdaptation.h"

    22 #include "XAAdaptation.h"

    23 

    24 

    25 /*

    26  * XAresult XACameraItfAdapt_SetFlashMode( XAAdaptationBaseCtx *bCtx, XAuint32 flashMode );

    27  */

    28 XAresult XACameraItfAdapt_SetFlashMode( XAAdaptationBaseCtx *bCtx, XAuint32 flashMode )

    29 {

    30     XAresult ret = XA_RESULT_SUCCESS;

    31     XAAdaptEvent event = {XA_CAMERAITFEVENTS,XA_CAMERACBEVENT_FLASHREADY,0,0};

    32     gint gstFlashmode;

    33 

    34     DEBUG_API_A1("->XACameraItfAdapt_SetFlashMode 0x%x",(int)flashMode);

    35     if(!bCtx || bCtx->ctxId != XACameraAdaptation)

    36     {

    37         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    38         return XA_RESULT_PARAMETER_INVALID;

    39     }

    40     switch( flashMode )

    41     {

    42          case XA_CAMERA_FLASHMODE_OFF:

    43              gstFlashmode = GST_PHOTOGRAPHY_FLASH_MODE_OFF;

    44              break;

    45          case XA_CAMERA_FLASHMODE_ON:

    46              gstFlashmode = GST_PHOTOGRAPHY_FLASH_MODE_ON;

    47              break;

    48          case XA_CAMERA_FLASHMODE_AUTO:

    49              gstFlashmode = GST_PHOTOGRAPHY_FLASH_MODE_AUTO;

    50              break;

    51          case XA_CAMERA_FLASHMODE_REDEYEREDUCTION:

    52              gstFlashmode = GST_PHOTOGRAPHY_FLASH_MODE_RED_EYE;

    53              break;

    54          case XA_CAMERA_FLASHMODE_FILLIN:

    55              gstFlashmode = GST_PHOTOGRAPHY_FLASH_MODE_FILL_IN;

    56              break;

    57          case XA_CAMERA_FLASHMODE_TORCH:

    58          case XA_CAMERA_FLASHMODE_REDEYEREDUCTION_AUTO:

    59          default:

    60              DEBUG_INFO("Mode not supported in GstPhotography!");

    61              return XA_RESULT_PARAMETER_INVALID;

    62              break;

    63     }

    64 

    65     if(GST_IS_PHOTOGRAPHY(bCtx->bin))

    66     {

    67         if ( !gst_photography_set_flash_mode( GST_PHOTOGRAPHY(bCtx->bin), gstFlashmode ) )

    68         {

    69             ret = XA_RESULT_INTERNAL_ERROR;

    70         }

    71     }

    72     if(ret == XA_RESULT_SUCCESS)

    73     {

    74         /* no gst event, senc cb now */

    75         XAAdaptationBase_SendAdaptEvents(bCtx, &event );

    76     }

    77 

    78     DEBUG_API("<-XACameraItfAdapt_SetFlashMode");

    79     return ret;

    80 }

    81 

    82 /*

    83  * XAresult XACameraItfAdapt_SetFocusMode( XAAdaptationBaseCtx *bCtx, XAuint32 focusMode,

    84  *                                              XAmillimeter manualSetting,

    85  *                                              XAboolean macroEnabled )

    86  */

    87 XAresult XACameraItfAdapt_SetFocusMode( XAAdaptationBaseCtx *bCtx, XAuint32 focusMode,

    88                                         XAmillimeter manualSetting, XAboolean macroEnabled )

    89 {

    90     XAresult ret = XA_RESULT_SUCCESS;

    91     XAAdaptEvent event = {XA_CAMERAITFEVENTS,XA_CAMERACBEVENT_FOCUSSTATUS,1,NULL};

    92     XAuint32 status;

    93 

    94     DEBUG_API_A3("->XACameraItfAdapt_SetFocusMode - focusMode:%d, manualSetting:%d, macroEnabled:%d",

    95                 (int)focusMode, (int)manualSetting, (int)macroEnabled);

    96     if(!bCtx || bCtx->ctxId != XACameraAdaptation)

    97     {

    98         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    99         return XA_RESULT_PARAMETER_INVALID;

   100     }

   101 

   102     if(GST_IS_PHOTOGRAPHY(bCtx->bin))

   103     {

   104         if ( focusMode == XA_CAMERA_FOCUSMODE_AUTO )

   105         {

   106             gst_photography_set_autofocus( GST_PHOTOGRAPHY(bCtx->bin), TRUE );

   107             status = XA_CAMERA_FOCUSMODESTATUS_REQUEST;

   108             event.data = &status;

   109         }

   110         else

   111         {

   112             /* Only auto focus supported in GstPhotography, other modes sets auto focus off */

   113             DEBUG_INFO("No support in GstPhotography");

   114             gst_photography_set_autofocus( GST_PHOTOGRAPHY(bCtx->bin), FALSE );

   115             status = XA_CAMERA_FOCUSMODESTATUS_OFF;

   116             event.data = &status;

   117             ret = XA_RESULT_FEATURE_UNSUPPORTED;

   118         }

   119     }

   120     else

   121     {

   122         status = XA_CAMERA_FOCUSMODESTATUS_OFF;

   123         event.data = &status;

   124     }

   125 

   126     if(event.data)

   127     {

   128         XAAdaptationBase_SendAdaptEvents(bCtx, &event );

   129     }

   130 

   131     DEBUG_API("<-XACameraItfAdapt_SetFocusMode");

   132     return ret;

   133 }

   134 

   135 /*

   136  * XAresult XACameraItfAdapt_SetFocusRegionPattern( XAAdaptationBaseCtx *bCtx,

   137  *                                                  XAuint32 focusPattern,

   138  *                                                  XAuint32 activePoints1,

   139  *                                                  XAuint32 activePoints2 )

   140  */

   141 XAresult XACameraItfAdapt_SetFocusRegionPattern( XAAdaptationBaseCtx *bCtx, XAuint32 focusPattern,

   142                                                     XAuint32 activePoints1, XAuint32 activePoints2 )

   143 {

   144     DEBUG_API_A3("->XACameraItfAdapt_SetFocusRegionPattern - focusPattern:%d, activePoints1:%d, activePoints2:%d",

   145                 (int)focusPattern,(int)activePoints1,(int)activePoints2);

   146     DEBUG_INFO("No support for focus region pattern in GstPhotography ");

   147     DEBUG_API("<-XACameraItfAdapt_SetFocusRegionPattern");

   148     return XA_RESULT_FEATURE_UNSUPPORTED;

   149 }

   150 

   151 /* XAresult XACameraItfAdapt_GetFocusRegionPositions( XAAdaptationBaseCtx *bCtx, XAuint32 *pNumPositionEntries,

   152  *                                                    XAFocusPointPosition *pFocusPosition )

   153  */

   154 XAresult XACameraItfAdapt_GetFocusRegionPositions( XAAdaptationBaseCtx *bCtx, XAuint32 *pNumPositionEntries,

   155                                                    XAFocusPointPosition *pFocusPosition )

   156 {

   157     DEBUG_API("->XACameraItfAdapt_GetFocusRegionPositions");

   158     DEBUG_INFO("No focus region support in GstPhotography");

   159     DEBUG_API("<-XACameraItfAdapt_GetFocusRegionPositions");

   160     return XA_RESULT_FEATURE_UNSUPPORTED;

   161 }

   162 

   163 /*

   164  * XAresult XACameraItfAdapt_SetMeteringMode( XAAdaptationBaseCtx *bCtx, XAuint32 meteringMode )

   165  */

   166 XAresult XACameraItfAdapt_SetMeteringMode( XAAdaptationBaseCtx *bCtx, XAuint32 meteringMode )

   167 {

   168     DEBUG_API_A1("->XACameraItfAdapt_SetMeteringMode - meteringMode:%d",(int)meteringMode);

   169     DEBUG_INFO("No metering modes support in GstPhotography");

   170     DEBUG_API("<-XACameraItfAdapt_SetMeteringMode");

   171     return XA_RESULT_FEATURE_UNSUPPORTED;

   172 }

   173 

   174 /*

   175  * XAresult XACameraItfAdapt_SetExposureMode( XAAdaptationBaseCtx *bCtx, XAuint32 exposure, XAuint32 compensation )

   176  */

   177 XAresult XACameraItfAdapt_SetExposureMode( XAAdaptationBaseCtx *bCtx, XAuint32 exposure, XAuint32 compensation )

   178 {

   179     XAresult ret = XA_RESULT_SUCCESS;

   180     XAAdaptEvent event = {XA_CAMERAITFEVENTS,XA_CAMERACBEVENT_EXPOSURESTATUS,1,NULL};

   181     GstSceneMode expmode;

   182 

   183     DEBUG_API_A2("->XACameraItfAdapt_SetExposureMode - exposure:%d, compensation:%d",

   184                 (int)exposure, (int)compensation);

   185     if(!bCtx || bCtx->ctxId != XACameraAdaptation)

   186     {

   187         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   188         return XA_RESULT_PARAMETER_INVALID;

   189     }

   190 

   191     switch(exposure)

   192     {

   193         case XA_CAMERA_EXPOSUREMODE_AUTO:

   194             expmode = GST_PHOTOGRAPHY_SCENE_MODE_AUTO;

   195             break;

   196         case XA_CAMERA_EXPOSUREMODE_SPORTS:

   197             expmode = GST_PHOTOGRAPHY_SCENE_MODE_SPORT;

   198             break;

   199         case XA_CAMERA_EXPOSUREMODE_PORTRAIT:

   200             expmode = GST_PHOTOGRAPHY_SCENE_MODE_PORTRAIT;

   201             break;

   202         case XA_CAMERA_EXPOSUREMODE_NIGHT:

   203             expmode = GST_PHOTOGRAPHY_SCENE_MODE_NIGHT;

   204             break;

   205         default:

   206             DEBUG_INFO("GstPhotography doesn't support other than manual settings");

   207             ret = XA_RESULT_FEATURE_UNSUPPORTED;

   208             break;

   209     }

   210 

   211     if(GST_IS_PHOTOGRAPHY(bCtx->bin)&&ret==XA_RESULT_SUCCESS)

   212     {

   213         if (!gst_photography_set_scene_mode( GST_PHOTOGRAPHY(bCtx->bin), expmode) )

   214         {

   215             ret = XA_RESULT_INTERNAL_ERROR;

   216         }

   217         else if (exposure == XA_CAMERA_EXPOSUREMODE_AUTO)

   218         {

   219             if (!gst_photography_set_ev_compensation( GST_PHOTOGRAPHY(bCtx->bin), compensation) )

   220             {

   221                 ret = XA_RESULT_INTERNAL_ERROR;

   222             }

   223         }

   224     }

   225     if(ret == XA_RESULT_SUCCESS)

   226     {

   227         event.data = &exposure;

   228         XAAdaptationBase_SendAdaptEvents(bCtx, &event );

   229     }

   230 

   231     DEBUG_API("<-XACameraItfAdapt_SetExposureMode");

   232     return ret;

   233 }

   234 

   235 /*

   236  * XAresult XACameraItfAdapt_SetISOSensitivity( XAAdaptationBaseCtx *bCtx, XAuint32 isoSensitivity, XAuint32 manualSetting )

   237  */

   238 XAresult XACameraItfAdapt_SetISOSensitivity( XAAdaptationBaseCtx *bCtx, XAuint32 isoSensitivity, XAuint32 manualSetting )

   239 {

   240     XAresult ret = XA_RESULT_SUCCESS;

   241 

   242     DEBUG_API_A2("->XACameraItfAdapt_SetISOSensitivity - isoSensitivity:%d, manualSetting:%d",

   243                 (int)isoSensitivity, (int)manualSetting);

   244     if(!bCtx || bCtx->ctxId != XACameraAdaptation)

   245     {

   246         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   247         return XA_RESULT_PARAMETER_INVALID;

   248     }

   249 

   250     if ( isoSensitivity ==  XA_CAMERA_ISOSENSITIVITYMODE_MANUAL)

   251     {

   252         if(GST_IS_PHOTOGRAPHY(bCtx->bin))

   253         {

   254             if ( !gst_photography_set_iso_speed (GST_PHOTOGRAPHY(bCtx->bin), manualSetting ) )

   255             {

   256                 ret = XA_RESULT_INTERNAL_ERROR;

   257             }

   258         }

   259     }

   260     else

   261     {

   262         DEBUG_INFO("Iso sensitivity auto not supported in GstPhotography, stubbed value");

   263         ret = XA_RESULT_SUCCESS;

   264     }

   265 

   266     DEBUG_API("<-XACameraItfAdapt_SetISOSensitivity");

   267     return ret;

   268 }

   269 

   270 /*

   271  * XAresult XACameraItfAdapt_SetAperture( XAAdaptationBaseCtx *bCtx, XAuint32 aperture, XAuint32 manualSetting )

   272  */

   273 XAresult XACameraItfAdapt_SetAperture( XAAdaptationBaseCtx *bCtx, XAuint32 aperture, XAuint32 manualSetting )

   274 {

   275     XAresult ret = XA_RESULT_SUCCESS;

   276 

   277     DEBUG_API_A2("->XACameraItfAdapt_SetAperture - aperture:%d, manualSetting:%d",

   278                 (int)aperture, (int)manualSetting);

   279     if(!bCtx || bCtx->ctxId != XACameraAdaptation)

   280     {

   281         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   282         return XA_RESULT_PARAMETER_INVALID;

   283     }

   284 

   285     if ( aperture == XA_CAMERA_APERTUREMODE_MANUAL )

   286     {

   287         if(GST_IS_PHOTOGRAPHY(bCtx->bin))

   288         {

   289             if (!gst_photography_set_aperture ( GST_PHOTOGRAPHY(bCtx->bin), manualSetting) )

   290             {

   291                 ret = XA_RESULT_INTERNAL_ERROR;

   292             }

   293         }

   294     }

   295     else

   296     {

   297         DEBUG_INFO("GstPhotography doesn't support auto aperture settings");

   298         ret = XA_RESULT_FEATURE_UNSUPPORTED;

   299     }

   300 

   301     DEBUG_API("<-XACameraItfAdapt_SetAperture");

   302     return ret;

   303 }

   304 

   305 /*

   306  * XAresult XACameraItfAdapt_SetShutterSpeed( XAAdaptationBaseCtx *bCtx, XAuint32 shutterSpeed, XAmicrosecond manualSetting )

   307  */

   308 XAresult XACameraItfAdapt_SetShutterSpeed( XAAdaptationBaseCtx *bCtx, XAuint32 shutterSpeed, XAmicrosecond manualSetting )

   309 {

   310     DEBUG_API_A2("->XACameraItfAdapt_SetShutterSpeed - shutterSpeed:%d, manualSetting:%d",

   311                 (int)shutterSpeed, (int)manualSetting);

   312     DEBUG_INFO("Shutter speed setting not supported in GstPhotography");

   313     DEBUG_API("<-XACameraItfAdapt_SetShutterSpeed");

   314     return XA_RESULT_FEATURE_UNSUPPORTED;

   315 }

   316 

   317 /*

   318  * XAresult XACameraItfAdapt_SetWhiteBalance( XAAdaptationBaseCtx *bCtx, XAuint32 whiteBalance, XAuint32 manualSetting )

   319  */

   320 XAresult XACameraItfAdapt_SetWhiteBalance( XAAdaptationBaseCtx *bCtx, XAuint32 whiteBalance, XAuint32 manualSetting )

   321 {

   322     XAresult ret = XA_RESULT_SUCCESS;

   323     GstWhiteBalanceMode gstWbMode;

   324 

   325     DEBUG_API_A2("->XACameraItfAdapt_SetWhiteBalance - whiteBalance:%d, manualSetting:%d",

   326                 (int)whiteBalance, (int)manualSetting);

   327     if(!bCtx || bCtx->ctxId != XACameraAdaptation)

   328     {

   329         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   330         return XA_RESULT_PARAMETER_INVALID;

   331     }

   332 

   333     switch ( whiteBalance )

   334     {

   335     case XA_CAMERA_WHITEBALANCEMODE_AUTO:

   336         gstWbMode = GST_PHOTOGRAPHY_WB_MODE_AUTO;

   337         break;

   338     case XA_CAMERA_WHITEBALANCEMODE_SUNLIGHT:

   339         gstWbMode = GST_PHOTOGRAPHY_WB_MODE_DAYLIGHT;

   340         break;

   341     case XA_CAMERA_WHITEBALANCEMODE_CLOUDY:

   342         gstWbMode = GST_PHOTOGRAPHY_WB_MODE_CLOUDY;

   343         break;

   344     case XA_CAMERA_WHITEBALANCEMODE_TUNGSTEN:

   345         gstWbMode = GST_PHOTOGRAPHY_WB_MODE_TUNGSTEN;

   346         break;

   347     case XA_CAMERA_WHITEBALANCEMODE_FLUORESCENT:

   348         gstWbMode = GST_PHOTOGRAPHY_WB_MODE_FLUORESCENT;

   349         break;

   350     case XA_CAMERA_WHITEBALANCEMODE_SUNSET:

   351         gstWbMode = GST_PHOTOGRAPHY_WB_MODE_SUNSET;

   352         break;

   353     case XA_CAMERA_WHITEBALANCEMODE_INCANDESCENT:

   354     case XA_CAMERA_WHITEBALANCEMODE_FLASH:

   355     case XA_CAMERA_WHITEBALANCEMODE_MANUAL:

   356     case XA_CAMERA_WHITEBALANCEMODE_SHADE:

   357         DEBUG_INFO("Wanted white balance mode not supported!");

   358         return XA_RESULT_FEATURE_UNSUPPORTED;

   359         break;

   360     default:

   361         break;

   362     }

   363 

   364     if(GST_IS_PHOTOGRAPHY(bCtx->bin))

   365     {

   366         if ( !gst_photography_set_white_balance_mode( GST_PHOTOGRAPHY(bCtx->bin), gstWbMode ) )

   367         {

   368             ret = XA_RESULT_INTERNAL_ERROR;

   369         }

   370     }

   371 

   372     DEBUG_API("<-XACameraItfAdapt_SetWhiteBalance");

   373     return ret;

   374 }

   375 

   376 /*

   377  * XAresult XACameraItfAdapt_SetAutoLocks( XAAdaptationBaseCtx *bCtx, XAuint32 locks )

   378  */

   379 XAresult XACameraItfAdapt_SetAutoLocks( XAAdaptationBaseCtx *bCtx, XAuint32 locks )

   380 {

   381     DEBUG_API_A1("->XACameraItfAdapt_SetAutoLocks - locks:%d", (int)locks);

   382     DEBUG_INFO("No autolocks support in GstPhotography")

   383     DEBUG_API("<-XACameraItfAdapt_SetAutoLocks");

   384     return XA_RESULT_FEATURE_UNSUPPORTED;

   385 }

   386 

   387 /*

   388  * XAresult XACameraItfAdapt_SetZoom( XAAdaptationBaseCtx *bCtx, XAuint32 zoom, XAboolean digitalEnabled, XAuint32 speed, XAboolean async )

   389  */

   390 XAresult XACameraItfAdapt_SetZoom( XAAdaptationBaseCtx *bCtx, XAuint32 zoom, XAboolean digitalEnabled, XAuint32 speed, XAboolean async )

   391 {

   392     XAresult ret = XA_RESULT_SUCCESS;

   393     XAAdaptEvent event = {XA_CAMERAITFEVENTS,XA_CAMERACBEVENT_ZOOMSTATUS,1,NULL};

   394     gint gstZoom;

   395 

   396     DEBUG_API_A4("->XACameraItfAdapt_SetZoom - zoom:%d,digitalEnabled:%d,speed:%d,async:%d ",

   397                     (int)zoom,(int)digitalEnabled,(int)speed,(int)async);

   398     if(!bCtx || bCtx->ctxId != XACameraAdaptation || zoom < 1 )

   399     {

   400         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   401         return XA_RESULT_PARAMETER_INVALID;

   402     }

   403 

   404     if ( zoom > 10 )

   405     {

   406         gstZoom = MAX_ZOOM;

   407     }

   408     else

   409     {

   410         /* Gst Zoom range 100 - 1000, 100 = 1x, 200 = 2x, ...*/

   411         gstZoom = zoom * 100;

   412     }

   413     if(GST_IS_PHOTOGRAPHY(bCtx->bin))

   414     {

   415         if ( !gst_photography_set_zoom( GST_PHOTOGRAPHY(bCtx->bin), gstZoom ) )

   416         {

   417             ret = XA_RESULT_INTERNAL_ERROR;

   418         }

   419     }

   420     if( ret == XA_RESULT_SUCCESS && async )

   421     {

   422         /* no gst event, send cb now*/

   423         event.data = &zoom;

   424         XAAdaptationBase_SendAdaptEvents(bCtx, &event );

   425     }

   426 

   427     DEBUG_API("<-XACameraItfAdapt_SetZoom");

   428     return ret;

   429 }