/*

* 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 <gst.h>

#include <photography.h>

#include "XACameraAdaptCtx.h"

#include "XACameraItfAdaptation.h"

#include "XAAdaptation.h"

/*

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

 */

XAresult XACameraItfAdapt_SetFlashMode( XAAdaptationBaseCtx *bCtx, XAuint32 flashMode )

{

    XAresult ret = XA_RESULT_SUCCESS;

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

    gint gstFlashmode;

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

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

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        return XA_RESULT_PARAMETER_INVALID;

    }

    switch( flashMode )

    {

         case XA_CAMERA_FLASHMODE_OFF:

             gstFlashmode = GST_PHOTOGRAPHY_FLASH_MODE_OFF;

             break;

         case XA_CAMERA_FLASHMODE_ON:

             gstFlashmode = GST_PHOTOGRAPHY_FLASH_MODE_ON;

             break;

         case XA_CAMERA_FLASHMODE_AUTO:

             gstFlashmode = GST_PHOTOGRAPHY_FLASH_MODE_AUTO;

             break;

         case XA_CAMERA_FLASHMODE_REDEYEREDUCTION:

             gstFlashmode = GST_PHOTOGRAPHY_FLASH_MODE_RED_EYE;

             break;

         case XA_CAMERA_FLASHMODE_FILLIN:

             gstFlashmode = GST_PHOTOGRAPHY_FLASH_MODE_FILL_IN;

             break;

         case XA_CAMERA_FLASHMODE_TORCH:

         case XA_CAMERA_FLASHMODE_REDEYEREDUCTION_AUTO:

         default:

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

             return XA_RESULT_PARAMETER_INVALID;

             break;

    }

    if(GST_IS_PHOTOGRAPHY(bCtx->bin))

    {

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

        {

            ret = XA_RESULT_INTERNAL_ERROR;

        }

    }

    if(ret == XA_RESULT_SUCCESS)

    {

        /* no gst event, senc cb now */

        XAAdaptationBase_SendAdaptEvents(bCtx, &event );

    }

    DEBUG_API("<-XACameraItfAdapt_SetFlashMode");

    return ret;

}

/*

 * XAresult XACameraItfAdapt_SetFocusMode( XAAdaptationBaseCtx *bCtx, XAuint32 focusMode,

 *                                              XAmillimeter manualSetting,

 *                                              XAboolean macroEnabled )

 */

XAresult XACameraItfAdapt_SetFocusMode( XAAdaptationBaseCtx *bCtx, XAuint32 focusMode,

                                        XAmillimeter manualSetting, XAboolean macroEnabled )

{

    XAresult ret = XA_RESULT_SUCCESS;

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

    XAuint32 status;

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

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

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

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        return XA_RESULT_PARAMETER_INVALID;

    }

    if(GST_IS_PHOTOGRAPHY(bCtx->bin))

    {

        if ( focusMode == XA_CAMERA_FOCUSMODE_AUTO )

        {

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

            status = XA_CAMERA_FOCUSMODESTATUS_REQUEST;

            event.data = &status;

        }

        else

        {

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

            DEBUG_INFO("No support in GstPhotography");

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

            status = XA_CAMERA_FOCUSMODESTATUS_OFF;

            event.data = &status;

            ret = XA_RESULT_FEATURE_UNSUPPORTED;

        }

    }

    else

    {

        status = XA_CAMERA_FOCUSMODESTATUS_OFF;

        event.data = &status;

    }

    if(event.data)

    {

        XAAdaptationBase_SendAdaptEvents(bCtx, &event );

    }

    DEBUG_API("<-XACameraItfAdapt_SetFocusMode");

    return ret;

}

/*

 * XAresult XACameraItfAdapt_SetFocusRegionPattern( XAAdaptationBaseCtx *bCtx,

 *                                                  XAuint32 focusPattern,

 *                                                  XAuint32 activePoints1,

 *                                                  XAuint32 activePoints2 )

 */

XAresult XACameraItfAdapt_SetFocusRegionPattern( XAAdaptationBaseCtx *bCtx, XAuint32 focusPattern,

                                                    XAuint32 activePoints1, XAuint32 activePoints2 )

{

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

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

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

    DEBUG_API("<-XACameraItfAdapt_SetFocusRegionPattern");

    return XA_RESULT_FEATURE_UNSUPPORTED;

}

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

 *                                                    XAFocusPointPosition *pFocusPosition )

 */

XAresult XACameraItfAdapt_GetFocusRegionPositions( XAAdaptationBaseCtx *bCtx, XAuint32 *pNumPositionEntries,

                                                   XAFocusPointPosition *pFocusPosition )

{

    DEBUG_API("->XACameraItfAdapt_GetFocusRegionPositions");

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

    DEBUG_API("<-XACameraItfAdapt_GetFocusRegionPositions");

    return XA_RESULT_FEATURE_UNSUPPORTED;

}

/*

 * XAresult XACameraItfAdapt_SetMeteringMode( XAAdaptationBaseCtx *bCtx, XAuint32 meteringMode )

 */

XAresult XACameraItfAdapt_SetMeteringMode( XAAdaptationBaseCtx *bCtx, XAuint32 meteringMode )

{

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

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

    DEBUG_API("<-XACameraItfAdapt_SetMeteringMode");

    return XA_RESULT_FEATURE_UNSUPPORTED;

}

/*

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

 */

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

{

    XAresult ret = XA_RESULT_SUCCESS;

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

    GstSceneMode expmode;

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

                (int)exposure, (int)compensation);

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

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        return XA_RESULT_PARAMETER_INVALID;

    }

    switch(exposure)

    {

        case XA_CAMERA_EXPOSUREMODE_AUTO:

            expmode = GST_PHOTOGRAPHY_SCENE_MODE_AUTO;

            break;

        case XA_CAMERA_EXPOSUREMODE_SPORTS:

            expmode = GST_PHOTOGRAPHY_SCENE_MODE_SPORT;

            break;

        case XA_CAMERA_EXPOSUREMODE_PORTRAIT:

            expmode = GST_PHOTOGRAPHY_SCENE_MODE_PORTRAIT;

            break;

        case XA_CAMERA_EXPOSUREMODE_NIGHT:

            expmode = GST_PHOTOGRAPHY_SCENE_MODE_NIGHT;

            break;

        default:

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

            ret = XA_RESULT_FEATURE_UNSUPPORTED;

            break;

    }

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

    {

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

        {

            ret = XA_RESULT_INTERNAL_ERROR;

        }

        else if (exposure == XA_CAMERA_EXPOSUREMODE_AUTO)

        {

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

            {

                ret = XA_RESULT_INTERNAL_ERROR;

            }

        }

    }

    if(ret == XA_RESULT_SUCCESS)

    {

        event.data = &exposure;

        XAAdaptationBase_SendAdaptEvents(bCtx, &event );

    }

    DEBUG_API("<-XACameraItfAdapt_SetExposureMode");

    return ret;

}

/*

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

 */

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

{

    XAresult ret = XA_RESULT_SUCCESS;

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

                (int)isoSensitivity, (int)manualSetting);

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

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        return XA_RESULT_PARAMETER_INVALID;

    }

    if ( isoSensitivity ==  XA_CAMERA_ISOSENSITIVITYMODE_MANUAL)

    {

        if(GST_IS_PHOTOGRAPHY(bCtx->bin))

        {

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

            {

                ret = XA_RESULT_INTERNAL_ERROR;

            }

        }

    }

    else

    {

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

        ret = XA_RESULT_SUCCESS;

    }

    DEBUG_API("<-XACameraItfAdapt_SetISOSensitivity");

    return ret;

}

/*

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

 */

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

{

    XAresult ret = XA_RESULT_SUCCESS;

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

                (int)aperture, (int)manualSetting);

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

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        return XA_RESULT_PARAMETER_INVALID;

    }

    if ( aperture == XA_CAMERA_APERTUREMODE_MANUAL )

    {

        if(GST_IS_PHOTOGRAPHY(bCtx->bin))

        {

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

            {

                ret = XA_RESULT_INTERNAL_ERROR;

            }

        }

    }

    else

    {

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

        ret = XA_RESULT_FEATURE_UNSUPPORTED;

    }

    DEBUG_API("<-XACameraItfAdapt_SetAperture");

    return ret;

}

/*

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

 */

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

{

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

                (int)shutterSpeed, (int)manualSetting);

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

    DEBUG_API("<-XACameraItfAdapt_SetShutterSpeed");

    return XA_RESULT_FEATURE_UNSUPPORTED;

}

/*

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

 */

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

{

    XAresult ret = XA_RESULT_SUCCESS;

    GstWhiteBalanceMode gstWbMode;

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

                (int)whiteBalance, (int)manualSetting);

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

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        return XA_RESULT_PARAMETER_INVALID;

    }

    switch ( whiteBalance )

    {

    case XA_CAMERA_WHITEBALANCEMODE_AUTO:

        gstWbMode = GST_PHOTOGRAPHY_WB_MODE_AUTO;

        break;

    case XA_CAMERA_WHITEBALANCEMODE_SUNLIGHT:

        gstWbMode = GST_PHOTOGRAPHY_WB_MODE_DAYLIGHT;

        break;

    case XA_CAMERA_WHITEBALANCEMODE_CLOUDY:

        gstWbMode = GST_PHOTOGRAPHY_WB_MODE_CLOUDY;

        break;

    case XA_CAMERA_WHITEBALANCEMODE_TUNGSTEN:

        gstWbMode = GST_PHOTOGRAPHY_WB_MODE_TUNGSTEN;

        break;

    case XA_CAMERA_WHITEBALANCEMODE_FLUORESCENT:

        gstWbMode = GST_PHOTOGRAPHY_WB_MODE_FLUORESCENT;

        break;

    case XA_CAMERA_WHITEBALANCEMODE_SUNSET:

        gstWbMode = GST_PHOTOGRAPHY_WB_MODE_SUNSET;

        break;

    case XA_CAMERA_WHITEBALANCEMODE_INCANDESCENT:

    case XA_CAMERA_WHITEBALANCEMODE_FLASH:

    case XA_CAMERA_WHITEBALANCEMODE_MANUAL:

    case XA_CAMERA_WHITEBALANCEMODE_SHADE:

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

        return XA_RESULT_FEATURE_UNSUPPORTED;

        break;

    default:

        break;

    }

    if(GST_IS_PHOTOGRAPHY(bCtx->bin))

    {

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

        {

            ret = XA_RESULT_INTERNAL_ERROR;

        }

    }

    DEBUG_API("<-XACameraItfAdapt_SetWhiteBalance");

    return ret;

}

/*

 * XAresult XACameraItfAdapt_SetAutoLocks( XAAdaptationBaseCtx *bCtx, XAuint32 locks )

 */

XAresult XACameraItfAdapt_SetAutoLocks( XAAdaptationBaseCtx *bCtx, XAuint32 locks )

{

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

    DEBUG_INFO("No autolocks support in GstPhotography")

    DEBUG_API("<-XACameraItfAdapt_SetAutoLocks");

    return XA_RESULT_FEATURE_UNSUPPORTED;

}

/*

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

 */

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

{

    XAresult ret = XA_RESULT_SUCCESS;

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

    gint gstZoom;

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

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

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

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        return XA_RESULT_PARAMETER_INVALID;

    }

    if ( zoom > 10 )

    {

        gstZoom = MAX_ZOOM;

    }

    else

    {

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

        gstZoom = zoom * 100;

    }

    if(GST_IS_PHOTOGRAPHY(bCtx->bin))

    {

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

        {

            ret = XA_RESULT_INTERNAL_ERROR;

        }

    }

    if( ret == XA_RESULT_SUCCESS && async )

    {

        /* no gst event, send cb now*/

        event.data = &zoom;

        XAAdaptationBase_SendAdaptEvents(bCtx, &event );

    }

    DEBUG_API("<-XACameraItfAdapt_SetZoom");

    return ret;

}