/*

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

#include <assert.h>

#include "xaimagecontrolsitf.h"

#include "xaimagecontrolsitfadaptation.h"

/**

 * XAImageControlsItfImpl* GetImpl(XAVolumeItf self)

 * Description: Validated interface pointer and cast it to implementations pointer.

 **/

static XAImageControlsItfImpl* GetImpl(XAImageControlsItf self)

{

    if(self)

    {

        XAImageControlsItfImpl* impl = (XAImageControlsItfImpl*)(*self);

        if(impl && (impl == impl->self))

        {

            return impl;

        }

    }

    return NULL;

}

/**

 * Base interface XAImageControlsItf implementation

 */

/**

 * XAresult XAImageControlsItfImpl_SetBrightness(XAImageControlsItf self,

 *                                               XAuint32 brightness)

 * Description: Sets the brightness level.

 **/

XAresult XAImageControlsItfImpl_SetBrightness(XAImageControlsItf self,

                                              XAuint32 brightness)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAImageControlsItfImpl* impl = GetImpl(self);

    DEBUG_API("->XAImageControlsItfImpl_SetBrightness");

    if(!impl || brightness > MAX_BRIGHTNESS_VALUE)

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        /* invalid parameter */

        DEBUG_API("<-XAImageControlsItfImpl_SetBrightness");

        return XA_RESULT_PARAMETER_INVALID;

    }

    ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

    if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )

    {

        DEBUG_API("<-XAImageControlsItfImpl_SetBrightness");

        return ret;

    }

    ret = XAImageControlsItfAdapt_SetBrightness((XAAdaptationGstCtx*)impl->adapCtx, brightness);

    if(ret == XA_RESULT_SUCCESS)

    {

        impl->brightness = brightness;

    }

    XAAdaptationBase_ThreadExit(impl->adapCtx);

    DEBUG_API("<-XAImageControlsItfImpl_SetBrightness");

    return ret;

}

/**

 * XAresult XAImageControlsItfImpl_SetBrightness(XAImageControlsItf self,

 *                                               XAuint32 *pBrightness)

 * Description: Gets the current brightness level.

 **/

XAresult XAImageControlsItfImpl_GetBrightness(XAImageControlsItf self,

                                              XAuint32 *pBrightness)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAImageControlsItfImpl* impl = GetImpl(self);

    DEBUG_API("->XAImageControlsItfImpl_GetBrightness");

    if(!impl || !pBrightness)

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        /* invalid parameter */

        DEBUG_API("<-XAImageControlsItfImpl_GetBrightness");

        return XA_RESULT_PARAMETER_INVALID;

    }

    *pBrightness = impl->brightness;

    DEBUG_API("<-XAImageControlsItfImpl_GetBrightness");

    return ret;

}

/**

 * XAresult XAImageControlsItfImpl_SetContrast(XAImageControlsItf self,

 *                                             XAint32 contrast)

 * Description: Sets the contrast level.

 **/

XAresult XAImageControlsItfImpl_SetContrast(XAImageControlsItf self,

                                            XAint32 contrast)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAImageControlsItfImpl* impl = GetImpl(self);

    DEBUG_API("->XAImageControlsItfImpl_SetContrast");

    if(!impl || (contrast < MIN_CONTRAST_VALUE || contrast > MAX_CONTRAST_VALUE))

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        /* invalid parameter */

        DEBUG_API("<-XAImageControlsItfImpl_SetContrast");

        return XA_RESULT_PARAMETER_INVALID;

    }

    ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

    if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED)

    {

        DEBUG_API("<-XAImageControlsItfImpl_SetContrast");

        return ret;

    }

    ret = XAImageControlsItfAdapt_SetContrast((XAAdaptationGstCtx*)impl->adapCtx, contrast);

    if(ret == XA_RESULT_SUCCESS)

    {

        impl->contrast = contrast;

    }

    XAAdaptationBase_ThreadExit(impl->adapCtx);

    DEBUG_API("<-XAImageControlsItfImpl_SetContrast");

    return ret;

}

/**

 * XAresult XAImageControlsItfImpl_GetContrast(XAImageControlsItf self,

 *                                             XAint32 *pContrast)

 * Description: Gets the contrast level.

 **/

XAresult XAImageControlsItfImpl_GetContrast(XAImageControlsItf self,

                                            XAint32 *pContrast)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAImageControlsItfImpl* impl = GetImpl(self);

    DEBUG_API("->XAImageControlsItfImpl_GetContrast");

    if(!impl || !pContrast)

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        /* invalid parameter */

        DEBUG_API("<-XAImageControlsItfImpl_GetContrast");

        return XA_RESULT_PARAMETER_INVALID;

    }

    *pContrast = impl->contrast;

    DEBUG_API("<-XAImageControlsItfImpl_GetContrast");

    return ret;

}

/**

 * XAresult XAImageControlsItfImpl_SetGamma(XAImageControlsItf self,

 *                                          XApermille gamma)

 * Description: Sets the gamma level.

 **/

XAresult XAImageControlsItfImpl_SetGamma(XAImageControlsItf self,

                                         XApermille gamma)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAImageControlsItfImpl* impl = GetImpl(self);

    XApermille  minGammaValue = 0;

    XApermille  maxGammaValue = 0;

    XAuint32    numSettings = 0;

    DEBUG_API("->XAImageControlsItfImpl_SetGamma");

    /* check supported min and max gamma levels */

    ret = XAImageControlsItfImpl_GetSupportedGammaSettings(self, &minGammaValue,

                                                           &maxGammaValue, &numSettings, NULL);

    if(!impl || (gamma < minGammaValue || gamma > maxGammaValue) ||

       ret != XA_RESULT_SUCCESS)

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        /* invalid parameter */

        DEBUG_API("<-XAImageControlsItfImpl_SetGamma");

        return XA_RESULT_PARAMETER_INVALID;

    }

    ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

    if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )

    {

        DEBUG_API("<-XAImageControlsItfImpl_SetGamma");

        return ret;

    }

    ret = XAImageControlsItfAdapt_SetGamma((XAAdaptationGstCtx*)impl->adapCtx, gamma);

    if(ret == XA_RESULT_SUCCESS)

    {

        impl->gamma = gamma;

    }

    XAAdaptationBase_ThreadExit(impl->adapCtx);

    DEBUG_API("<-XAImageControlsItfImpl_SetGamma");

    return ret;

}

/**

 * XAresult XAImageControlsItfImpl_GetGamma(XAImageControlsItf self,

 *                                          XApermille *pGamma)

 * Description: Gets the gamma level.

 **/

XAresult XAImageControlsItfImpl_GetGamma(XAImageControlsItf self,

                                         XApermille *pGamma)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAImageControlsItfImpl* impl = GetImpl(self);

    DEBUG_API("->XAImageControlsItfImpl_GetGamma");

    if(!impl || !pGamma)

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        /* invalid parameter */

        DEBUG_API("<-XAImageControlsItfImpl_GetGamma");

        return XA_RESULT_PARAMETER_INVALID;

    }

    *pGamma = impl->gamma;

    DEBUG_API("<-XAImageControlsItfImpl_GetGamma");

    return ret;

}

/**

 * XAresult XAImageControlsItfImpl_GetSupportedGammaSettings(XAImageControlsItf self,

 *                                                           XApermille *pMinValue,

 *                                                           XApermille *pMaxValue,

 *                                                           XAuint32 *pNumSettings,

 *                                                           XApermille **ppSettings)

 * Description: This method gets the supported gamma settings.

 **/

XAresult XAImageControlsItfImpl_GetSupportedGammaSettings(XAImageControlsItf self,

                                                          XApermille *pMinValue,

                                                          XApermille *pMaxValue,

                                                          XAuint32 *pNumSettings,

                                                          XApermille **ppSettings)

{

    XAresult ret = XA_RESULT_SUCCESS;

    XAImageControlsItfImpl* impl = GetImpl(self);

    DEBUG_API("->XAImageControlsItfImpl_GetSupportedGammaSettings");

    if(!impl || !pMinValue || !pMaxValue || !pNumSettings)

    {

        DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

        /* invalid parameter */

        DEBUG_API("<-XAImageControlsItfImpl_GetSupportedGammaSettings");

        return XA_RESULT_PARAMETER_INVALID;

    }

    ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

    if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )

    {

        DEBUG_API("<-XAImageControlsItfImpl_GetSupportedGammaSettings");

        return ret;

    }

    /* if ppSettings is non-null and non-continuos from min and max gamma value is

     * supported then pnunSettings is length of the ppSettings array. Else

     * pNumSettings returns the number of supported gamma settings. */

    if( ppSettings && pNumSettings != 0 )

    {

        /* solve array of supported gamma settings */

        ret = XAImageControlsItfAdapt_GetSupportedGammaSettings((XAAdaptationGstCtx*)impl->adapCtx,

                                                                pMinValue, pMaxValue,

                                                                pNumSettings, ppSettings);

    }

    else

    {

        /* Solve min and max values and numSettings */

        ret = XAImageControlsItfAdapt_GetSupportedGammaSettings((XAAdaptationGstCtx*)impl->adapCtx,

                                                                pMinValue, pMaxValue,

                                                                pNumSettings, NULL);

    }

    XAAdaptationBase_ThreadExit(impl->adapCtx);

    DEBUG_API("<-XAImageControlsItfImpl_GetSupportedGammaSettings");

    return ret;

}

/**

 * XAImageControlsItfImpl -specific methods

 **/

/**

 * XAImageControlsItfImplImpl* XAImageControlsItfImpl_Create()

 * @return  XAImageControlsItfImplImpl* - Pointer to  ImageControlsItf interface implementation

 **/

XAImageControlsItfImpl* XAImageControlsItfImpl_Create(XAAdaptationBaseCtx *adapCtx)

{

    XAImageControlsItfImpl* self = (XAImageControlsItfImpl*)

        calloc(1,sizeof(XAImageControlsItfImpl));

    DEBUG_API("->XAImageControlsItfImpl_Create");

    if(self)

    {

        /* init itf default implementation */

        self->itf.GetBrightness = XAImageControlsItfImpl_GetBrightness;

        self->itf.GetContrast = XAImageControlsItfImpl_GetContrast;

        self->itf.GetGamma = XAImageControlsItfImpl_GetGamma;

        self->itf.GetSupportedGammaSettings = XAImageControlsItfImpl_GetSupportedGammaSettings;

        self->itf.SetBrightness = XAImageControlsItfImpl_SetBrightness;

        self->itf.SetContrast = XAImageControlsItfImpl_SetContrast;

        self->itf.SetGamma = XAImageControlsItfImpl_SetGamma;

        /* init variables */

        self->brightness = DEFAULT_BRIGHTNESS_VALUE;

        self->contrast = DEFAULT_CONTRAST_VALUE;

        self->gamma = DEFAULT_GAMMA_VALUE;

        self->adapCtx = adapCtx;

        self->self = self;

    }

    DEBUG_API("<-XAImageControlsItfImpl_Create");

    return self;

}

/**

 * void XAImageControlsItfImpl_Free(XAImageControlsItfImpl* self)

 * @param  XAImageControlsItfImpl* self -

 **/

void XAImageControlsItfImpl_Free(XAImageControlsItfImpl* self)

{

    DEBUG_API("->XAImageControlsItfImpl_Free");

    assert(self==self->self);

    free(self);

    DEBUG_API("<-XAImageControlsItfImpl_Free");

}