/*

* 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 "XAAdaptation.h"

#include "XAMediaPlayerAdaptCtx.h"

#include "XAMediaRecorderAdaptCtx.h"

#include "XACameraAdaptCtx.h"

#include "XAImageControlsItfAdaptation.h"

/*

 * XAresult XAImageControlsItfAdapt_SetBrightness(XAAdaptationBaseCtx *bCtx,

 *                                                XAuint32 brightness)

 */

XAresult XAImageControlsItfAdapt_SetBrightness(XAAdaptationBaseCtx *bCtx,

                                               XAuint32 brightness)

{

    XAresult ret = XA_RESULT_SUCCESS;

    gdouble gstBrightness = 0;

    XAint32 tempBrightness = 0;

    GstElement *balanceElement = NULL;

    DEBUG_API("->XAImageControlsItfAdapt_SetBrightness")

    if(!bCtx || (bCtx->ctxId != XAMediaPlayerAdaptation && bCtx->ctxId != XAMediaRecorderAdaptation

       && bCtx->ctxId != XACameraAdaptation))

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        DEBUG_API("<-XAImageControlsItfAdapt_SetBrightness")

        return XA_RESULT_PARAMETER_INVALID;

    }

    if( bCtx->ctxId == XAMediaRecorderAdaptation )

    {

        XAMediaRecorderAdaptationCtx* ctx = (XAMediaRecorderAdaptationCtx*) bCtx;

        balanceElement = gst_bin_get_by_name( GST_BIN(ctx->baseObj.bin), "pp_balance");

    }

    if( bCtx->ctxId == XAMediaPlayerAdaptation )

    {

        XAMediaPlayerAdaptationCtx* ctx = (XAMediaPlayerAdaptationCtx*) bCtx;

        balanceElement = gst_bin_get_by_name( GST_BIN(ctx->baseObj.bin), "pp_balance");

    }

    if( bCtx->ctxId == XACameraAdaptation )

    {

        XACameraAdaptationCtx* ctx = (XACameraAdaptationCtx*) bCtx;

        GstElement *videoPP = gst_bin_get_by_name( GST_BIN(ctx->baseObj.bin), "videopp_camera");

        if ( !videoPP )

        {

            DEBUG_ERR("Could not receive videopp from camerabin!");

        }

        else

        {

            /* Get camera balance element */

            balanceElement = gst_bin_get_by_name( GST_BIN(videoPP), "pp_balance");

        }

    }

    /* count gstBrightness from XA contrast. Allowed values for gst is -1 to 1

     * and allowed value for XA is 0 to 100 */

    tempBrightness = brightness;

    gstBrightness = ( ((gdouble)tempBrightness - SCALE_VALUE_BRIGHTNESS) / SCALE_VALUE_BRIGHTNESS );

    if(balanceElement)

    {

        g_object_set(G_OBJECT(balanceElement), "brightness", gstBrightness, NULL);

        if(bCtx->ctxId == XAMediaPlayerAdaptation)

        {

            ret = XAImageControlsItfAdapt_HandleImageType(bCtx);

        }

    }

	if ( balanceElement )

	{

        gst_object_unref(balanceElement);

	}

    DEBUG_API("<-XAImageControlsItfAdapt_SetBrightness")

    return ret;

}

/*

 * XAresult XAImageControlsItfAdapt_SetContrast(XAAdaptationBaseCtx *bCtx,

 *                                              XAuint32 contrast)

 */

XAresult XAImageControlsItfAdapt_SetContrast(XAAdaptationBaseCtx *bCtx,

                                             XAint32 contrast)

{

    XAresult ret = XA_RESULT_SUCCESS;

    gdouble gstContrast = 1;

    GstElement *balanceElement = NULL;

    DEBUG_API("->XAImageControlsItfAdapt_SetContrast")

    if(!bCtx || (bCtx->ctxId != XAMediaPlayerAdaptation && bCtx->ctxId != XAMediaRecorderAdaptation

       && bCtx->ctxId != XACameraAdaptation))

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        DEBUG_API("<-XAImageControlsItfAdapt_SetContrast")

        return XA_RESULT_PARAMETER_INVALID;

    }

    if( bCtx->ctxId == XAMediaPlayerAdaptation )

    {

        XAMediaPlayerAdaptationCtx* ctx = (XAMediaPlayerAdaptationCtx*) bCtx;

        balanceElement = gst_bin_get_by_name( GST_BIN(ctx->baseObj.bin), "pp_balance");

    }

    if( bCtx->ctxId == XAMediaRecorderAdaptation )

    {

        XAMediaRecorderAdaptationCtx* ctx = (XAMediaRecorderAdaptationCtx*) bCtx;

        balanceElement = gst_bin_get_by_name( GST_BIN(ctx->baseObj.bin), "pp_balance");

    }

    if( bCtx->ctxId == XACameraAdaptation )

    {

        XACameraAdaptationCtx* ctx = (XACameraAdaptationCtx*) bCtx;

        GstElement *videoPP = gst_bin_get_by_name( GST_BIN(ctx->baseObj.bin), "videopp_camera");

        if( !videoPP )

        {

            DEBUG_ERR("Could not receive videopp from camerabin!");

        }

        else

        {

            /* Get camera balance element */

            balanceElement = gst_bin_get_by_name( GST_BIN(videoPP), "pp_balance");

        }

    }

    /* count gstContrast from XA contrast. Allowed values for gst is 0 to 2

     * and allowed value for XA is -100 to 100 */

    gstContrast = (( (gdouble)contrast + SCALE_VALUE_CONTRAST ) / SCALE_VALUE_CONTRAST );

    if(balanceElement)

    {

        g_object_set(G_OBJECT(balanceElement), "contrast", gstContrast, NULL);

        if(bCtx->ctxId == XAMediaPlayerAdaptation)

        {

            ret = XAImageControlsItfAdapt_HandleImageType(bCtx);

        }

    }

	if ( balanceElement )

	{

        gst_object_unref(balanceElement);

	}

    DEBUG_API("<-XAImageControlsItfAdapt_SetContrast")

    return ret;

}

/*

 * XAresult XAImageControlsItfAdapt_SetGamma(XAAdaptationBaseCtx *bCtx,

 *                                           XApermille gamma)

 */

XAresult XAImageControlsItfAdapt_SetGamma(XAAdaptationBaseCtx *bCtx,

                                          XApermille gamma)

{

    XAresult ret = XA_RESULT_SUCCESS;

    gdouble gstGamma=0;

    GstElement *gammaElement = NULL;

    DEBUG_API("->XAImageControlsItfAdapt_SetGamma")

    if(!bCtx || (bCtx->ctxId != XAMediaPlayerAdaptation && bCtx->ctxId != XAMediaRecorderAdaptation

       && bCtx->ctxId != XACameraAdaptation))

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        DEBUG_API("<-XAImageControlsItfAdapt_SetGamma")

        return XA_RESULT_PARAMETER_INVALID;

    }

    if( bCtx->ctxId == XAMediaPlayerAdaptation )

    {

        XAMediaPlayerAdaptationCtx* ctx = (XAMediaPlayerAdaptationCtx*) bCtx;

        gammaElement = gst_bin_get_by_name( GST_BIN(ctx->baseObj.bin), "pp_gamma");

    }

    if( bCtx->ctxId == XAMediaRecorderAdaptation )

    {

        XAMediaRecorderAdaptationCtx* ctx = (XAMediaRecorderAdaptationCtx*) bCtx;

        gammaElement = gst_bin_get_by_name( GST_BIN(ctx->baseObj.bin), "pp_gamma");

    }

    if( bCtx->ctxId == XACameraAdaptation )

    {

        XACameraAdaptationCtx* ctx = (XACameraAdaptationCtx*) bCtx;

        GstElement *videoPP = gst_bin_get_by_name( GST_BIN(ctx->baseObj.bin), "videopp_camera");

        if( !videoPP )

        {

            DEBUG_ERR("Could not receive videopp from camerabin!");

        }

        else

        {

            /* Get camera gamma element */

            gammaElement = gst_bin_get_by_name( GST_BIN(videoPP), "pp_gamma");

        }

    }

    /* count gstGamma from XA gamma */

    gstGamma = ( (gdouble)gamma / SCALE_VALUE_GAMMA );

    if(gammaElement)

    {

        g_object_set(G_OBJECT(gammaElement), "gamma", gstGamma, NULL);

        if(bCtx->ctxId == XAMediaPlayerAdaptation)

        {

            ret = XAImageControlsItfAdapt_HandleImageType(bCtx);

        }

    }

	if ( gammaElement )

	{

        gst_object_unref(gammaElement);

	}

    DEBUG_API("<-XAImageControlsItfAdapt_SetGamma")

    return ret;

}

/*

 * XAresult XAImageControlsItfAdapt_GetSupportedGammaSettings(XAAdaptationBaseCtx *bCtx,

 *                                                            XApermille *pMinValue,

 *                                                            XApermille *pMaxValue,

 *                                                            XAuint32 *pNumSettings,

 *                                                            XApermille **ppSettings)

 */

XAresult XAImageControlsItfAdapt_GetSupportedGammaSettings(XAAdaptationBaseCtx *bCtx,

                                                           XApermille *pMinValue,

                                                           XApermille *pMaxValue,

                                                           XAuint32 *pNumSettings,

                                                           XApermille **ppSettings)

{

    XAresult ret = XA_RESULT_SUCCESS;

    DEBUG_API("->XAImageControlsItfAdapt_GetSupportedGammaSettings")

    if(!bCtx || (bCtx->ctxId != XAMediaPlayerAdaptation && bCtx->ctxId != XAMediaRecorderAdaptation

       && bCtx->ctxId != XACameraAdaptation) || !pMinValue || !pMaxValue || !pNumSettings)

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        /* invalid parameter */

        DEBUG_API("<-XAImageControlsItfAdapt_GetSupportedGammaSettings")

        return XA_RESULT_PARAMETER_INVALID;

    }

    *pMinValue = MIN_GAMMA_VALUE;

    *pMaxValue = MAX_GAMMA_VALUE;

    /* manual settings is continuous from min to max then pNumSetting return 0. */

    *pNumSettings = 0;

    DEBUG_API("<-XAImageControlsItfAdapt_GetSupportedGammaSettings")

    return ret;

}

/*

 * XAresult XAImageControlsItfAdapt_ThreadEntry(XAAdaptationBaseCtx *adapCtx)

 * Description: Safety thread entry

 */

XAresult XAImageControlsItfAdapt_ThreadEntry(XAAdaptationBaseCtx *adaptCtx)

{

    DEBUG_API("->XAImageControlsItfAdapt_ThreadEntry");

    if((!adaptCtx ) ||( adaptCtx->ctxId != XAMediaPlayerAdaptation &&

                        adaptCtx->ctxId != XAMediaRecorderAdaptation &&

                        adaptCtx->ctxId != XACameraAdaptation ))

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        DEBUG_API("<-XAImageControlsItfAdapt_ThreadEntry");

        /* invalid parameter */

        return XA_RESULT_PARAMETER_INVALID;

    }

    if ( adaptCtx->ctxId == XAMediaPlayerAdaptation )

    {

        XA_IMPL_THREAD_SAFETY_ENTRY(XATSMediaPlayer);

    }

    else if( adaptCtx->ctxId == XAMediaRecorderAdaptation )

    {

        XA_IMPL_THREAD_SAFETY_ENTRY(XATSMediaRecorder);

    }

    else if (adaptCtx->ctxId == XACameraAdaptation )

    {

        XA_IMPL_THREAD_SAFETY_ENTRY(XATSCamera);

    }

    DEBUG_API("<-XAImageControlsItfAdapt_ThreadEntry");

    return XA_RESULT_SUCCESS;

}

/*

 * XAresult XAImageControlsItfAdapt_ThreadExit(XAAdaptationBaseCtx *adaptCtx)

 * Description: Safety thread exit

 */

XAresult XAImageControlsItfAdapt_ThreadExit(XAAdaptationBaseCtx *adaptCtx)

{

    DEBUG_API("->XAImageControlsItfAdapt_ThreadExit");

    if((!adaptCtx ) ||( adaptCtx->ctxId != XAMediaPlayerAdaptation &&

                        adaptCtx->ctxId != XAMediaRecorderAdaptation &&

                        adaptCtx->ctxId != XACameraAdaptation ))

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        DEBUG_API("<-XAImageControlsItfAdapt_ThreadExit");

        /* invalid parameter */

        return XA_RESULT_PARAMETER_INVALID;

    }

    if ( adaptCtx->ctxId == XAMediaPlayerAdaptation )

    {

        XA_IMPL_THREAD_SAFETY_EXIT(XATSMediaPlayer);

    }

    else if( adaptCtx->ctxId == XAMediaRecorderAdaptation )

    {

        XA_IMPL_THREAD_SAFETY_EXIT(XATSMediaRecorder);

    }

    else if (adaptCtx->ctxId == XACameraAdaptation )

    {

        XA_IMPL_THREAD_SAFETY_EXIT(XATSCamera);

    }

    DEBUG_API("<-XAImageControlsItfAdapt_ThreadExit");

    return XA_RESULT_SUCCESS;

}

/*

 * XAresult XAImageControlsItfAdapt_HandleImageType(XAAdaptationBaseCtx *bCtx)

 * Description: this run gstreamer for image type

 *

 */

XAresult XAImageControlsItfAdapt_HandleImageType(XAAdaptationBaseCtx *bCtx)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XADataSource *dataSrc = NULL;

    GstStateChangeReturn gstRet = GST_STATE_CHANGE_SUCCESS;

    GstState gstOrigState = GST_STATE_PLAYING;

    GstState gstTmpState = GST_STATE_PLAYING;

    XAMediaPlayerAdaptationCtx* mCtx = NULL;

    DEBUG_API("->XAImageControlsItfAdapt_HandleImageType");

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

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        DEBUG_API("<-XAImageControlsItfAdapt_HandleImageType")

        return XA_RESULT_PARAMETER_INVALID;

    }

    mCtx = (XAMediaPlayerAdaptationCtx*) bCtx;

    dataSrc = mCtx->xaSource;

    if( dataSrc )

    {

        XAMediaType mediaType;

        ret = XACommon_CheckDataSource(dataSrc, &mediaType);

        if( ret == XA_RESULT_SUCCESS && mediaType == XA_MEDIATYPE_IMAGE )

        {

            gstOrigState = GST_STATE(bCtx->bin);

            DEBUG_INFO_A1("Sending change state request to state %d", GST_STATE_READY);

            gstRet = gst_element_set_state( GST_ELEMENT(bCtx->bin), GST_STATE_READY);

            gstTmpState = GST_STATE(bCtx->bin);

            DEBUG_INFO_A1("Sending change state request to state %d", gstOrigState);

            gstRet = gst_element_set_state( GST_ELEMENT(bCtx->bin), gstOrigState);

        }

    }

    DEBUG_API("<-XAImageControlsItfAdapt_HandleImageType");

    return ret;

}